Chapter 9 - Functions

함수는 간단히 statement들을 묶고 이름을 붙인 것이다. C에서 함수는 반드시 값을 리턴하지 않아도 되고, argument가 있지 않아도 된다. 

함수는 하나의 작은 프로그램이고 각각 선언과 statement를 가진다. 함수는 재사용이 가능하기 때문에 중복된 코드를 줄일 수 있다.

이제까지는 main이라는 함수만 사용했지만, 다른 함수들을 사용하게 될 것이다.

9.1 Defining and Calling Functions

두 수의 평균을 구하는 함수 average를 정의하기. 이 정의는 여기에선 main함수 바깥에, main보다 앞서서 적도록 하자. 이유는 9.2에 나올것

double average(double a, double b)

{

return (a + b) / 2;

}

double: average 함수의 return type

identifiers a and b(parameters of the function): average함수가 불려질 때 제공되는 두 숫자. 각각의 parameter 앞에 type이 따로 따로 적혀 있어야 한다(생략 불가능).

{}로 묶인 부분: body. 함수의 실행되는 부분.

함수를 호출할 때에는, 함수의 이름을 쓰고, 뒤이어 괄호 안에 arguments를 적는다. 

 

Function Definitions

return-type function-name ( parameters )

{

declarations

statements

}

return type에 대해: 배열을 return할 수는 없으나, 그 외에 제한은 없다.

함수의 type을 void로 지정하는 것은 그 함수가 어떤 값을 return하지 않는다는 것을 뜻한다.

만약 return-type을 생략하면 C89는 int로 간주한다. C99에서는 생략을 허용하지 않는다. 하지만 VS2015에서는 C89 방법을 따르는 듯 하다.

Function Calls

average(x, y)

print_count(i)

print_pun()    // void function

괄호가 뒤에 붙지 않으면 - average, print_count 오류가 나지는 않지만 아무일도 일어나지 않는다. 함수 호출이 되지 않는다.

void function 뒤에는 항상 세미콜론(;)을 붙여 statement로 만든다. 다른 type의 function은 어떤 값이 만들어지기 때문에 다른 변수에 넣거나, 프린트하거나 등등으로 사용할 수 있다. 

non-void function 뒤에 세미콜론이 붙어 statement가 되면, 어떤 값이 만들어지지만 쓰이지 않고 버려진다.

함수의 값이 버려진다는 것을 명확히 나타내기 위해서 함수 호출 앞에 (void) 라고 붙여줄 수 있다. "casting to void" = "throwing away"

서로 다른 함수 안에서 같은 이름의 변수가 선언될 때, 각각의 변수는 서로 다른 메모리에 저장되므로 서로의 값에 영향을 끼치지 않는다.

함수 내에 return statment가 여러개 올 수 있다. 그러나 그 중 단 하나만 실행 가능하다. 함수 내에서  return statement가 실행되면 함수는 그 값을 return하고 끝낸다.

9.2 Function Declarations

앞의 예에서 순서를 바꿔, main 함수가 앞에 오고, main 안에서 쓰이는 average 함수가 뒤에 오도록 배치해 보자. main에서는 그 함수에 대한 정보가 없다. 이 경우 컴파일러는 그 함수가 int value를 return한다고 간주한다. 이를 implicit declaration이라고 함. 그러나 사실은 average 함수의 return value는 double이기 때문에, 결국 오류가 발생한다. main 함수를 앞에 배치하면서 이같은 오류를 방지하기 위해 function declaration이 필요하다. 함수를 호출하기 전에 선언(declare)만 해 주면서 콤파일러에 그 함수의 간략한 정보를 미리 전달하는 것.

return-type function-name ( parameters ) ;

이 형태의 function declaration을 function prototype이라고 부른다. 이 용어는 옛 버전의 C에서 사용했던 스타일 - 괄호 안을 비워놓음 - 과 구분하기 위함. 

parameter의 경우에는, name은 생략하고 type만 입력해도 된다. 

ex) double average(double, double);

#pragma warning(disable:4996)

#include <stdio.h>

double average(double a, double b); /* DECLARATION */

int main(void)

{

double x, y, z;

printf("Enter three numbers: ");

scanf("%lf%lf%lf", &x, &y, &z);

printf("Average of %g and %g: %g\n", x, y, average(x, y));

printf("Average of %g and %g: %g\n", y, z, average(y, z));

printf("Average of %g and %g: %g\n", x, z, average(x, z));

return 0;

}

double average(double a, double b) /* DEFINITION */

{

return (a + b) / 2;

}

9.3 Arguments

parameters: 함수를 정의할 때 사용

arguments: 함수를 호출할 때 사용

두 용어의 차이에 대한 설명: http://ohgyun.com/410

의미를 엄격히 구분해서 사용하지는 않고, argument를 두 가지 모두의 의미로 사용하기도 함.

arguments are passed by value. 값이 복사되어 전달되며, 함수 내부에서 그 값이 바뀌더라도 argument의 복사된 값이 바뀌는 것이고 그 변수 자체는 바뀌지 않음. 

예를 들어 x라는 변수를 함수의 argument로 쓰고, 함수 내부에서 그 값을 바꿔버려도, 원래 x의 값은 변하지 않고 그대로 있다. 

Argument Conversions

parameters의 type과 맞지 않는 type이 arguments로 사용되는 것을 허용한다. 이 때 arguments를 형변환하게 되는데 규칙은 함수 호출에 앞서 prototype이나 정의가 있었는지 없었는지에 따라 다르다.

-호출에 앞서 prototype이 있었던 경우

각 arguments의 값은 parameters의 type에 맞게 암시적 형변환된다. 

-호출에 앞서 prototype이 없는 경우(이 방법은 안전하지 않다)

default argument promotion이 이루어짐. float는 double로, char나 short는 int로(integral promotion). C99에서는 integer promotion

Array Argmuments

배열은 종종 arguments로 사용된다. 배열의 parameter가 1차원 배열인 경우, 배열의 길이는 지정되지 않아도 되며 보통 지정하지 않는다.

int f(int a[])

그러나 배열의 길이를 전달은 해야 하는데 

int f(int a[], int n)과 같이 두번째 파라미터로 배열의 길이를 지정해 준다.

다차원 배열의 경우에는, 첫번째 차원의 길이만 생략 가능하고 나머지는 지정해야 한다.

#define LEN 10

int sum_two_dimensional_array(int a[][LEN], int n) {

...

}

9.4 The return Statement

non-void function의 경우 반드시 return statement를 통해 어떤 값이 return 되어야 한다.

return expression ;

return n >= 0 ? n : 0;

이 statement는 n이 0보다 크거나 같으면 n을, 아니면 0을 리턴한다.

void function에서는

return;

이렇게 뒤에 아무런 expression 없이 나타나기도 한다.

9.5 Program Termination

The exit Function

main 함수 내에 return statement를 넣는 것 외에 프로그램을 종료시키는 방법에는 exit 함수를 호출하는 것이 있다(stdlib.h에 속함). exit에 전달된 argument는 main의 return value와 동일한 의미(종료 시점의 프로그램 상태)이다. 0(=EXIT_SUCCESS)은 정상적인 종료를, 1(=EXIT_FAILURE)은 비정상적인 종료를 의미한다.

exit(EXIT_SUCCESS);    /* normal termination */

exit(EXIT_FAILURE);    /* abnormal termination */

return expression;

exit(expression);    /* main안에서는 두 statement는 동일하다.

9.6 Recursion

자기 자신을 호출하는 함수를 재귀적(recursive)이라고 한다. factorial이나 power를 구하는 함수에서 이용할 수 있다. 어떤 언어는 recursion에게 굉장히 의존하고, 허용조차 하지 않는 언어도 있는데 C언어는 그 중간 쯤에 있다.

/* function computes factorial of n recursively */

int fact(int n)

{

if (n <= 1)

return 1;

else

return n * fact(n - 1);

}

/* power function using conditional expression */

int power(int x, int n)

{

return n == 0 ? 1 : x * power(x, n - 1);

}

The Quicksort Algorithm

사실 위에 예를 든 두 함수는 재귀가 굳이 필요하지 않다. 재귀는 자기 자신을 두번 혹은 그 이상 호출하는 복잡한 알고리즘에서 매우 유용하게 쓰인다.

divide-and-conquer: 큰 문제를 같은 알고리즘이 적용되는 작은 조각으로 나누어 해결하는 것. 가장 고전적인 예로 Quicksort algorithm이 있다.

1부터 n까지의 index가 있는 배열을 quicksort하는 방법:

1. 배열의 원소 e(partitioning element, 칸막이 원소?)를 선택하고, 원소 1, 2, ..., i-1 은 e보다 같거나 작고, 원소 i, i+1, ..., n은 e보다 크거나 같도록 배열을 재배열한다.

2. 1, ..., i-1까지의 원소를 Quicksort로 재귀적으로 sort한다.

3. i, ..., n까지의 원소를 Quicksort로 재귀적으로 sort한다.

Exercises

2번 

int check(int x, int y, int n) {

return  (x > 0 && x < n - 1 && y>0 && y < n - 1);

}

3번    최대공약수(GCD)를 구하는 함수

int gcd(int m, int n) {

int temp;

for (; n > 0; temp = m%n, m = n, n = temp);

return m;

}

4번    월, 일, 연도를 입력받아 날짜가 그 해의 몇번째 날인지 계산하는 함수

int day_of_year(int month, int day, int year) {

/* check input year is lunar year*/

int total = 0, i;

int days_of_months[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

if (year % 4 == 0) {

if (year % 100 == 0) {

if (year % 400 == 0) days_of_months[1] = 29;

}

else days_of_months[1] = 29;

}

for (i = 0; i < month - 1; i++)

total += days_of_months[i];

total += day;

return total;

}

5번    정수를 입력받아 몇 자리 수인지 구하는 함수

int num_digits(int n) {

int digits = 0;

while (n > 0) {

n /= 10;

digits++;

}

return digits;

}

6번  

int digit(int n, int k) {

int i;

for (i = 1; i < k; i++) {

n /= 10;

}

return n % 10;

}

10번

int exer10_a(int a[], int n) {

// (a) largest element in a

int max = a[0], i;

for (i = 1; i < n; i++) {

if (max < a[i])

max = a[i];

}

return max;

}

float exer10_b(int a[], int n) {

int total = 0, i;

float average;

for (i = 0; i < n; i++)

total += a[i];

average = (float)total / n;

return average;

}

int exer10_c(int a[], int n) {

int i, p = 0;

for (i = 0; i < n; i++)

if (a[i] > 0) p++;

return p;

}

11번    // 학점을 문자열로 받아서 평균평점 계산

float compute_GPA(char grades[], int n) {

int i, total=0;

for(i=0;i<n;i++)

switch (grades[i]) {

case 'a': case 'A':

total += 4;

break;

case 'b': case 'B':

total += 3;

break;

case 'c': case 'C':

total += 2;

break;

case 'd': case 'D':

total += 1;

break;

case 'f': case 'F':

break;

default:

printf("Invalid input.\n");

return 1;

}

return (float)total / n;

}

12번    // calculating inner product

double inner_product(double a[], double b[], int n) {

double product = 0;

int i;

for (i = 0; i < n; i++) 

product += a[i] * b[i];

return product;

}

13번    // 체스 보드의 말들로부터 백과 흑의 점수 계산

int evaluate_position(char board[8][8]) {

int i, j;

int value_white = 0;

int value_black = 0;

for (i = 0; i < 8; i++) {

for (j = 0; j < 8; j++) {

switch (board[i][j]) {

case 'Q': value_white += 9; break;

case 'R': value_white += 5; break;

case 'B': value_white += 3; break;

case 'N': value_white += 3; break;

case 'P': value_white += 1; break;

case 'q': value_black += 9; break;

case 'r': value_black += 5; break;

case 'b': value_black += 3; break;

case 'n': value_black += 3; break;

case 'p': value_black += 1; break;

}

}

}

return value_white - value_black;

}

14번    // 배열의 원소가 모두 0이면 true, 하나라도 nonzero element가 있으면 false를 리턴하는 함수

bool has_zero(int a[], int n) {

int i;

for (i = 0; i < n; i++) {

if (a[i] == 0);

else

return false;

}

return true;

}

15번

double median(double x, double y, double z) {

double result;

if (x <= y) {

if (y <= z) result = y;

else if (x <= z) result = z;

else result = x;

}

if (z <= y) result = y;

if (x <= z) result = x;

result = z;

return result;

}

16번    // fact 함수를 줄이기

long long fact1(int n) {

return n == 1 ? 1 : n * fact1(n - 1);

}

17번    // fact 함수를 재귀를 쓰지 않고 쓰기

long long fact2(int n) {

int i = 0;

long long result = 1;

for (i = 1; i <= n; i++) 

result *= i;

return result;

}

18번    // 재귀를 이용해 gcd함수 만들기

int gcd2(int m, int n) {

if (n == 0) return m;

else gcd2(n, m%n);

}

Programming Projects

1번   // selection sort

#include <stdio.h>

#pragma warning(disable:4996)

#define N 10

void selection_sort(int a[], int n) {

int i, max = a[0], max_index = 0;

int temp;

if (n == 1) return;

for (i = 1; i < n; i++) {

if (a[i] > max) {

max = a[i];

max_index = i;

}

}

temp = a[n - 1];

a[max_index] = temp;

a[n - 1] = max;

selection_sort(a, n - 1);

}

int main(void) {

int a[N], i;

printf("Enter %d numbers to be sorted: ", N);

for (i = 0; i < N; i++)

scanf("%d", &a[i]);

selection_sort(a, N);

printf("In sorted order: ");

for (i = 0; i < N; i++)

printf("%d ", a[i]);

printf("\n");

return 0;

}

2번    // income tax

float compute_tax(float income)

{

float tax;

if (income <= 750)

tax = .01f * income;

else if (income <= 2250)

tax = 7.50f + .02f * (income - 750);

else if (income <= 3750)

tax = 37.50f + .03f * (income - 2250);

else if (income <= 5250)

tax = 82.50f + .04f * (income - 3750);

else if (income <= 7000)

tax = 142.50f + .05f * (income - 5250);

else

tax = 230.00f + .06f * (income - 7000);

return tax;

}

int main(void) {

float income;

printf("Enter the amount of taxable income: ");

scanf("%f", &income);

printf("You have to pay $ %.2f for your income tax.\n", compute_tax(income));

return 0;

}

3번 알파벳 꼬물꼬물 (함수 사용해서)

#include <stdio.h>

#include <stdbool.h>

#include <time.h> // time function

#include <stdlib.h> // srand, rand function

void generate_random_walk(char walk[10][10]);

void print_array(char walk[10][10]);

void generate_random_walk(char walk[10][10]) {

int i, j, k;

int step = 1;

int move, open_direction;

bool possible_move[4];

// array initialization

for (i = 0; i < 10; i++) {

for (j = 0; j < 10; j++) 

walk[i][j] = '.';

}

i = j = 0;

walk[i][j] = 'A';

srand((unsigned)time(NULL));

while (step < 26) {

bool possible_move[4] = { 1,1,1,1 }; // up left down right

if (i == 0 || walk[i - 1][j] != '.')

possible_move[0] = 0;

if (j == 0 || walk[i][j - 1] != '.')

possible_move[1] = 0;

if (i == 9 || walk[i + 1][j] != '.')

possible_move[2] = 0;

if (j == 9 || walk[i][j + 1] != '.')

possible_move[3] = 0;

open_direction = 0; // 이동 가능한 방향의 갯수. 4방향 모두 이동 가능하면 4, 모든 방향이 막혔으면 0

for (k = 0; k < 4; k++)

open_direction += possible_move[k];

if (open_direction == 0) // 아무 방향으로도 움직일 수 없으면 랜덤워크 종료

return;

do { move = rand() % 4; } while (possible_move[move] == 0); // 막히지 않은 방향이 나올 때까지 move를 1~4 사이의 값으로 랜덤으로 구한다.

switch (move) {

case 0: i--; break;

case 1: j--; break;

case 2: i++; break;

case 3: j++; break;

}

walk[i][j] = 'A' + step;

step++;

}

}

void print_array(char walk[10][10]) {

int i, j;

for (i = 0; i < 10; i++) {

for (j = 0; j < 10; j++)

printf("%3c", walk[i][j]);

printf("\n");

}

}

int main(void) {

char board[10][10];

generate_random_walk(board);

print_array(board);

}

4번 아나그램 체크

#include <stdio.h>

#include <stdbool.h>

#include <ctype.h>

void read_word(int counts[26]);

bool equal_array(int counts1[26], int counts2[26]);

void read_word(int counts[26]) {

char c;

printf("Enter a word: ");

while ((c = getchar()) != '\n')

{

c = toupper(c);

if (c >= 65 && c <= 90)

counts[c - 65]++;

}

}

bool equal_array(int counts1[26], int counts2[26]) {

int i;

for (i = 0; i < 26; i++) {

if (counts1[i] - counts2[i])

return false;

}

return true;

}

int main(void) {

int word1[26] = { 0 };

int word2[26] = { 0 };

read_word(word1);

read_word(word2);

if (equal_array(word1, word2))

printf("Two words are anagrams.\n");

else

printf("Two words are NOT anagrams.\n");

}

5번 마방진

//    책에서는 배열을 char로 선언했으나 배열의 값이 127까지만 지원되기 때문에 int로 선언하는게 맞는것으로 보인다.

#include <stdio.h>

#pragma warning(disable:4996)

void create_magic_square(int n, int magic_square[99][99]);

void print_magic_square(int n, int magic_square[99][99]);

int main(void) {

int n;

int board[99][99] = { 0 };

printf("Enter the size of square(odd number, between 1 and 99: ");

scanf("%d", &n);

if (n % 2 == 0) {

printf("You can't enter even number.\n");

return 0;

}

create_magic_square(n, board);

print_magic_square(n, board);

return 0;

}

void create_magic_square(int n, int magic_square[99][99]) {

int i = 0, j = (n - 1) / 2, k, new_i, new_j;

for (k = 1; k <= n*n; k++) {

magic_square[i][j] = k;

new_i = (i == 0) ?  n - 1 : i - 1;

new_j = (j == n - 1) ?  0 : j + 1;

if (magic_square[new_i][new_j] != 0) {

new_i = (i == n - 1) ? 0 : i + 1;

new_j = j;

}

i = new_i; j = new_j;

}

}

void print_magic_square(int n, int magic_square[99][99]) {

int i, j;

for (i = 0; i < n; i++) {

for (j = 0; j < n; j++)

printf("%3d", magic_square[i][j]);

printf("\n");

}

}

6번 polynomial

#include <stdio.h>

#include <math.h>

#pragma warning(disable:4996)

double poly(double x);

int main(void) {

double x;

printf("Enter value of x: ");

scanf("%lf", &x);

printf("%f\n", poly(x));

return 0;

}

double poly(double x) {

return 3 * pow(x, 5) + 2 * pow(x, 4) - 5 * pow(x, 3) - x*x + 7 * x - 6;

}

7번 power function(재귀회수를 줄인)

#include <stdio.h>

#pragma warning(disable:4996)

double power2(double x, int n);

int main(void) {

double x;

int n;

printf("Input double x, int n: ");

printf("value of x^n: ");

printf("%f\n", power2(x, n));

return 0;

}

double power2(double x, int n) {

if (n == 0)

return 1;

if (n % 2 == 0)

return power2(x, n / 2) * power2(x, n / 2);

else

return x * power2(x, n - 1);

}

8번 주사위 게임

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#include <stdbool.h>

#include <ctype.h>

#pragma warning(disable:4996)

int roll_dice(void);

bool play_game(void);

int main(void) {

int wins = 0, loses = 0;

char play_again;

srand((unsigned)time(NULL));

do {

if (play_game() == true) {

printf("You win!\n");

wins++;

}

else {

loses++;

printf("You lose!\n");

}

printf("\nPlay again? ");

scanf(" %c", &play_again);

// play_again의 값이 '\n'이 되는걸 방지하기 위해 %c 앞에 빈 칸을 하나 둬서 whitespace 문자를 무시하게 한다.

printf("\n");

} while (toupper(play_again) == 'Y');

printf("Wins: %d\tLosses: %d\n", wins, loses);

return 0;

}

int roll_dice(void) {

int dice1, dice2;

dice1 = rand() % 6 + 1;

dice2 = rand() % 6 + 1;

return dice1 + dice2;

}

bool play_game(void) {

int sum, point;

sum = roll_dice();

printf("You rolled: %d\n", sum);

if (sum == 7 || sum == 11)

return true;

else if (sum == 2 || sum == 3 || sum == 12)

return false;

else {

point = sum;

printf("Your point is %d\n", point);

}

while (1) {

sum = roll_dice();

printf("You rolled: %d\n", sum);

if (sum == point)

return true;

else if (sum == 7)

return false;

}

}