` Ⅵ. 함수와 메모리 유형 C에서 함수를 사용하는 목적은 바로 계산 결과를 이용하기 위해서이다. 그런데 계산 결과도 하 나의 데이터이기 때문에 역시 특정 데이터 유형을 갖게 된다. 그리고 C에서는 반드시 하나의 데 이터 유형의 값만 계산 결과로 산출하도록 되어 있다. 이는 어느 때는 2를(즉 정수 데이터 유형 의 값을) 어느 때는 2.2를(즉 실수 데이터 유형의 값을) 계산 결과로 산출할 수는 없다는 얘기가 된다(정수값만 산출하거나 아니면 실수값만 산출하여야 한다). C에서의 함수는 특정 작업을 수행하고 그 결과를 넘겨주는 역할을 하는데, 예를 들어 다음과 같 은 출력을 내는 프로그램을 작성한다고 하면... ┌────────────────────────────────────────────┐ │********************************************************************** │ │ OUTPUT BY HONG GIL DONG │ │********************************************************************** │ │ INPUT DATA1 │ │********************************************************************** │ │ OUTPUT1 │ │********************************************************************** │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 이를 printf로 출력시키면 되지만 이경우는 for 문을 사용하여 반복 출력하는 것이 편한데... #include main() { int i; for (i = 1; i <= 70; i++) /* 첫번째로 '*'를 70개 출력시킴 */ putchar('*'); putchar('\n'); printf(" OUTPUT BY HONG GIL DONG\n"); for (i = 1; i <= 70; i++) /* 두번째로 '*'를 70개 출력시킴 */ putchar('*'); putchar('\n'); printf(" INPUT DATA1\n"); for (i = 1; i <= 70; i++) /* 세번째로 '*'를 70개 출력시킴 */ putchar('*'); putchar('\n'); printf(" OUTPUT1\n"); for (i = 1; i <= 70; i++) /* 네번째로 '*'를 70개 출력시킴 */ putchar('*'); putchar('\n'); } 위의 프로그램을 보면 다음 문장이 4번 반복되는 것을 알 수 있다. ┌────────────────────────────────────────────┐ │ for (i = 1; i <= 70; i++) │ │ putchar('*'); │ │ putchar('\n'); │ │ │ └────────────────────────────────────────────┘ 따라서 이를 한번만 입력하고 필요할 때마다 불러 쓰면 편한데... 그래서 사용하게 된 것이 바로 함수이다. 위의 경우 함수를 사용하게 되면 다음과 같이 된다. ┌────────────────────────────────────────────┐ │ #include │ │ print_star() { -----+ │ │ int i; | │ │ for (i = 1; i <= 70; i++) | '*'를 70개 출력시키는 함수 │ │ putchar('*'); | │ │ putchar('\n'); | │ │ } -----+ │ │ │ │ main() { │ │ print_star(); <───────────── ① │ │ printf(" OUTPUT BY HONG GIL DONG\n"); │ │ print_star(); <───────────── ② │ │ printf(" INPUT DATA1\n"); │ │ print_star(); <───────────── ③ │ │ printf(" OUTPUT1\n"); │ │ print_star(); <───────────── ④ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위의 프로그램을 앞의 프로그램과 비교해 보면 훨씬 정리된 느낌을 줄 것이다. 또 print_star란 것이 '*'를 한 줄 출력시키는 것이라는 것을 안다면 위의 프로그램이 앞의 프로그램 보다 훨씬 더 이해하기 쉽다. 그리고 위의 print_star는 필요할 때마다 사용할 수 있고 다른 사람의 다른 프 로그램에서도 사용할 수 있다는 장점을 갖게 되는데 이것이 함수를 사용하는 가장 큰 이유라고 할 수 있다. 그러나 함수를 많이 사용하면 수행시간이 많이 걸리기 때문에 속도는 떨어지게 된다. 따라서 속도에 민감한 프로그램을 작성하고자 할 때에는 함수의 사용에 신중을 기해야 한다. 다음은 함수 호출이 어떻게 처리되는지를 나타내는 프로그램이다. ┌────────────────────────────────────────────┐ │ main() { | ② │ │ int i = 10; |① +-----------------------------→ sum(int x, int y) { │ │ int j = 100; | | | printf("sum = %d\n",x+y); │ │ sum(i, j); ↓---+ ④ ③ | ++x; │ │ ++i; ←----------------------------+ | ++y; │ │ ++j; | | | printf("x = %d, y = %d\n",x,y); │ │ printf("%d ,i+j); |⑤ +---↓ } │ │ } ↓ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 일단 함수 호출문까지 수행된다(①). sum이라고 하는 함수 호출을 만나게 되면 실제로 sum함수 로 제어가 이동하여(②), 이를 차례대로 수행하게 된다(③). 수행후 함수의 끝에 도달하게 되면, 제어가 자신을 부른 함수, 즉 main으로 다시 돌아가게 되며(이때 sum 호출이 있던 부분으로 돌 아간다)(④), 그 다음 부분부터 차례대로 수행하게 된다(⑤). 위의 경우에는 함수 호출 자체가 하 나의 문장이었으므로 그 다음 문장부터 수행하지만 함수 호출이 수식 내의 일부였을 때에는 그 수식을 계속 계산하게 된다. < 함수의 정의와 호출 > ⑴ 함수의 정의 ┌────────────────────────────────────────────┐ │ [메모리 유형] [데이터 유형] 함수 이름 ( [형식인자1,.....형식인자n] ) │ │ { [함수 프로그램] } │ └────────────────────────────────────────────┘ 우선 메모리 유형은 이 함수를 어떤 곳에서 사용할 수 있는 가를 나타내는데 여기서는 일단 생 략되었다고 가정한다. 데이터 유형은 바로 이 함수가 계산하는 계산 결과의 데이터 유형을 의미 한다(모든 함수는 계산 결과가 있기 때문에 이 데이터 유형도 반드시 있어야 한다). 그러나 계산 결과가 int 데이터 유형일 경우 생략할 수 있다. 지금까지 사용한 main도 함수이기 때문에 계산 결과가 있는데 이의 데이터 유형이 생략되었으므로 바로 int 유형의 값을 계산 결과로 산출하는 함수였음을 알 수 있다. 함수이름은 그 함수가 하는 역할에 따라 적당하게 알아보기 쉬운 말을 쓰면 되는데 이는 변수의 이름과 같이 알파벳과 숫자를 섞어 사용할 수 있으며 시작은 역시 알파 벳으로 시작하여야 한다. 함수 이름 다음의 소괄호는 앞의 이름이 함수라는 것을 알려주는 기호 이기 때문에 반드시 있어야 하며 소괄호 안에는 인자들의 목록이 오는데 이 인자들을 특별히 형 식 인자라고 한다(형식 인자들은 변수 선언과 같은 형태로 오게 된다). 그 다음의 중괄호는 함수 의 실제 내용인 프로그램을 둘러싸고 있는 것으로 역시 반드시 와야 한다. 특히 프로그램이 없는 경우에도 중괄호는 있어야 한다. 중괄호 안에는 바로 이 함수에 대한 프로그램이 오는데 main에 서와 같이 변수를 선언하여 사용할 수도 있다. 위 함수의 정의에서 [ ]로 둘러싸인 부분은 생략할 수 있다. 따라서 가장 간단한 함수는 다음과 같이 된다. ┌────────────────────────────────────────────┐ │ do_noting() { │ │ } │ └────────────────────────────────────────────┘ 위 함수는 프로그램이 없기 때문에 하는 일도 없다. 그렇기 때문에 아무것도 하는게 없는 함수 라고 할 수 있는데 계산 결과의 데이터 유형만은 int이다. 따라서 계산 결과의 데이터 유형이 있 다고 해서 반드시 계산 결과가 있는 것은 아니라는 것을 알 수 있다. 다음은 이보다 조금 더 복잡한 함수의 한 예이다. ┌────────────────────────────────────────────┐ │ print_hello() { │ │ printf("Hello!\n"); │ │ } │ │ │ └────────────────────────────────────────────┘ 이 함수를 부르게 되면 언제나 Hello!란 메시지를 출력하게 된다. 그리고 함수 이름 앞에 데이터 유형이 생략되었기 때문에 int 데이터 유형의 값을 계산 결과로 산출하는 것이 되나 위 함수에서 는 계산 결과라는 것이 아예 없다. 따라서 위의 함수는 일만 하고 계산 결과는 없는 함수이다. 다음 함수의 예를 살펴보자. ┌────────────────────────────────────────────┐ │ sum(int x, int y) { │ │ printf("x + y = %d\n",x+y); │ │ } │ │ │ └────────────────────────────────────────────┘ 위 함수에서는 드디어 인자가 사용되었다. 위의 함수 sum은 두 개의 인자를 갖는데 첫번째 인 자의 이름은 x이며 이의 데이터 유형은 int이다. 따라서 첫번째 인자로는 정수 데이터가 와야 한 다. 마찬가지로 두번째 인자의 이름은 y이며 이의 데이터 유형도 int이기 때문에 위의 함수 sum 을 사용하려면 sum(10,20)과 같이 두 개의 정수 데이터를 인자로 주어야 한다. 또 다음 함수를 살펴보자. ┌────────────────────────────────────────────┐ │ float sum2(float x, float y) { │ │ return (x+y); │ │ } │ │ │ └────────────────────────────────────────────┘ 위 함수에서도 인자를 역시 2개를 갖는데 둘 다 float 데이터 유형으로 이 sum2란 함수는 float 데이터 유형의 값을 계산 결과로 산출함을 의미한다. 그 다음 실제 하는 일은 바로 return 문으로 이루어져 있으며 이 return 문은 함수의 계산 결과를 산출하는 문장으로 위의 함수 sum2는 x+y 를 계산 결과로 산출하게 된다. 다음에 나오는 함수는 지금까지의 함수 가운데 제일 복잡한 형태로 되어 있다. ┌────────────────────────────────────────────┐ │ long int power(int n) { │ │ int i; │ │ long int res = 1l; │ │ if (n < 0) │ │ return (-1l); │ │ else if (n == 0) │ │ return (1); │ │ else { │ │ for (i = 1; i <= n; i++) │ │ res *= i; │ │ return (res); │ │ } │ │ } │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위 함수가 계산 결과로 산출하는 값의 데이터 유형은 long int이며 int 유형의 인자를 한 개 갖 는다. 그리고 자체적으로 int 유형의 변수 i와 long int 유형의 변수 res를 정의하여 사용하고 있 는데 이 변수는 물론 위의 함수 내에서만 사용할 수 있다. ⑵ 함수의 호출 ┌────────────────────────────────────────────┐ │ 함수 이름(실인자1,.....실인자n) │ └────────────────────────────────────────────┘ 즉 원하는 함수의 이름 다음에 괄호를 붙이고 그 안에 인자의 값을 주면 되는데, 인자가 없는 함수의 경우라도 괄호는 절대로 생략할 수 없다. 따라서 앞의 do_nothing 함수를 호출하고자 할 때에는 다음과 같이 사용하면 된다. ┌────────────────────────────────────────────┐ │ do_nothing() │ └────────────────────────────────────────────┘ do_nothing은 실제로 하는 일이 없으므로 위와 같이 호출하여도 아무런 변화도 발생하지 않는 다. 그러나 print_hello를 호출하게 되면 ┌────────────────────────────────────────────┐ │ print_hello() │ └────────────────────────────────────────────┘ Hello!라는 메시지가 화면에 나타나게 된다. 반면에 sum 함수의 경우에는 두 개의 인자가 있기 때문에 다음과 같이 두 개의 값을 지정하여 호출하여야 한다. ┌────────────────────────────────────────────┐ │ sum(2,3) │ └────────────────────────────────────────────┘ 이때 sum 다음의 인자들은 sum 함수의 형식 인자들에 다음과 같이 차례대로 할당된다. ┌────────────────────────────────────────────┐ │ +---+2는 x에 전달 │ │ sum(2,3)|------------------------ 함수 호출(실인자) │ │ +-+------+3은 y에 전달 │ │ | | │ │ sum(int x, int y)-{-------------- 함수 정의(형식인자) │ │ printf("x + y = %d\n",x+y); │ │ } │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 함수 정의에서의 인자들은 값이 없다(이는 당연히 초기값도 줄 수가 없다). 이들이 값을 갖게 되 는 것은 바로 함수 호출시 같이 지정한 인자들을 통해서이다. 따라서 앞의 예의 경우에는 x가 2, y가 3이 되므로 x + y = 5라고 하는 출력이 나오게 된다. 함수 호출은 수식의 하나로 간주되며 이는 함수 호출을 수식 내에서 사용할 수 있음을 의미한 다. 또 함수 호출에 ';'만 붙이면 바로 수식문이, 즉 문장이 됨을 의미한다. 따라서 다음과 같이 사용할 수 있다. ┌────────────────────────────────────────────┐ │ sum(1,5); │ └────────────────────────────────────────────┘ 함수 호출도 수식이기 때문에 계산 결과가 있어야 하는데 함수 호출의 계산 결과는 바로 그 함 수의 계산 결과가 된다. 따라서 power 함수를 다음과 같이 호출하였을 때. ┌────────────────────────────────────────────┐ │ 1+power(3) │ └────────────────────────────────────────────┘ power(3)의 계산 결과는 power 함수에 3이란 값의 실인자로 호출하였을 때의 계산 결과, 즉 6이 되며 따라서 1+power(3)은 7이 된다. 단 power는 계산 결과가 long int이기 때문에 1+power(3)의 계산은 int+long int가 되어 long int 유형이 된다. 그러면 다음의 예를 보자. ┌────────────────────────────────────────────┐ │ x = power(2)+power(3); │ └────────────────────────────────────────────┘ 위의 문장에서는 함수 호출이 2개나 있다(같은 수식 내에 함수 호출이 여러 개 있어도 문제가 되지 않는다). 이들을 계산하면 power(2)는 2, power(3)은 6이 되므로 결국 x = 2+6이 되며 부수 효과에 의해 x의 값도 8이된다. 또 다음 문장을 살펴보자. ┌────────────────────────────────────────────┐ │ y = power(power(3)); │ └────────────────────────────────────────────┘ 위 문장은 실인자로 또 함수 호출이 사용되었다. C의 실인자로 수식이 올 수 있기 때문에 위와 같이 당연히 함수 호출이 올 수 있다. 이경우 안의 함수 호출을 먼저 계산하므로 power(3)은 6이 되고 이는 power(6)이 되어 결국 y는 720의 값을 갖게 된다. 다음은 실제로 함수를 정의하여 사용하는 프로그램의 몇 가지 예이다. long factorial(int n) { /* long형을 되돌리는 함수 */ int i; long product = 1l; for (i = 2; i <= n; i++) product *= i; return product; } main() { int num; long fact; for (num = 1; num <= 10; num++) { fact = factorial(num); /* factorial 함수 호출뒤 fact에 대입 */ printf("%2d! = %8ld\n",num,fact); } } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800 위의 for 문은 fact 변수를 없애고 다음과 같이 간결하게 할 수도 있다. ┌────────────────────────────────────────────┐ │ for (num = 1; num <= 10; num++) │ │ printf("%2d! = %8ld\n",num,factorial(num)); │ └────────────────────────────────────────────┘ void a() { printf("This is function test.\n"); printf("Now in function a()\n"); } main() { int s; a(); /* a 함수 호출 */ sum(10,20); /* sum 함수를 실인자 10과 20으로 호출 */ s = sum(20,60); /* sum 함수를 20과 60으로 호출한 후 되돌림 값을 s에 저장 */ printf("sum from 20 to 60 = %d\n",s); printf("sum from 10 to 100 = %d\n",sum(10,100)); /* sum 함수의 되돌림 값을 printf함수의 변수로 사용 */ } int sum(int a, int b) { /* 정수형 변수 2개를 받아 정수형을 되돌리는 함수 */ int i, s = 0; printf("Now in function b()\n"); for (i = a; i <= b; i++) s = s + i; return s; /* s의 값을 호출한 함수에게 되돌린다 */ } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- This is function test. Now in function a() Now in function b() Now in function b() sum from 20 to 60 = 1640 Now in function b() sum from 10 to 100 = 5005 위 프로그램에서 처음의 sum 함수 호출에서의 되돌림 값은 아무곳에도 사용되지 않았다. 이와 같이 함수의 되돌림 값은 필요에 따라 무시될 수도 있다. 다음의 sum 함수 호출에서는 되돌림 값이 변수 s에 대입된 후 화면으로 출력되고 있으며 마지막의 printf 문을 보면 sum함수 자체가 직접 사용되고 있다. C에서는 함수의 되돌림 값이 꼭 어떤 변수에 대입될 필요는 없다. 이처럼 되돌림 값은 변수에 대입될 수도 있고 다른 함수 호출의 실인자로 직접 사용될 수도 있 음을 알 수가 있다. #include main() { char c; int vno = 0; /* 모음의 갯수를 기억할 변수 */ int cno = 0; /* 자음의 갯수를 기억할 변수 */ int uno = 0; /* 대문자의 갯수를 기억할 변수 */ int lno = 0; /* 소문자의 갯수를 기억할 변수 */ int dno = 0; /* 숫자의 갯수를 기억할 변수 */ while ((c = getchar()) != EOF) { if (is_vowel(c)) /* 읽은 문자가 모음이면 */ ++vno; /* 모음 숫자를 하나 증가 */ else if (is_alphabet(c)) /* 모음이 아닌 알파벳이면, 즉 자음이면 */ ++cno; /* 자음 숫자를 하나 증가 */ if (is_upper(c)) /* 읽은 문자가 대문자이면 */ ++uno; /* 대문자 숫자를 하나 증가 */ else if (is_lower(c)) /* 대문자가 아닌 소문자이면 */ ++lno; /* 소문자 숫자를 하나 증가 */ else if (is_digit(c)) /* 읽은 것이 숫자면 */ ++dno; /* 숫자 카운트를 하나 증가 */ } printf(" Number of Vowels : %d\n",vno); printf("Number of Consonants : %d\n",cno); printf("Number of Uppercases : %d\n",uno); printf("Number of Lowercases : %d\n",lno); printf(" Number of Digits : %d\n",dno); } is_vowel(char c) { switch (c) { case 'a': case 'e': case 'i': case 'o': case 'u': case 'A': case 'E': case 'I': case 'O': case 'U': return (1); /* 문자가 모음인 경우 참인 1을 계산 결과로 산출 */ default : return (0); /* 모음이 아니므로 거짓인 0을 계산 결과로 산출 */ } } is_alphabet(char c) { /* 주어진 문자가 영문 알파벳인지 판단하는 함수 */ return (is_upper(c) || is_lower(c)); } is_upper(char c) { /* 주어진 문자가 대문자인지 판단하는 함수 */ return (c >= 'A' && c <= 'Z'); } is_lower(char c) { /* 주어진 문자가 소문자인지 판단하는 함수 */ return (c >= 'a' && c <= 'z'); } is_digit(char c) { /* 주어진 문자가 숫자인지 판단하는 함수 */ return (c >= '0' && c <= '9'); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- C:\TC>count < readme 뇌 Number of Vowels : 5370 Number of Consonants : 9072 Number of Uppercases : 2481 Number of Lowercases : 11961 Number of Digits : 265 ※ 함수와 서브루틴 다른 프로그래밍 언어에는 두가지 종류의 함수가 있다. 원래 의미의 함수와 서브루틴(또는 프로 시저)이라고 부르는 것들인데, 서브루틴(subroutine)은 계산 결과가 없고 일만 하는데 반해 함수 는 계산 결과가 반드시 있다. 예를 들어 다음 프로그램의 경우 ┌────────────────────────────────────────────┐ │ print_hello() { │ │ printf("Hello!\n"); │ │ } │ │ │ └────────────────────────────────────────────┘ Hello!라는 메시지를 출력시키는 일만 하고 계산 결과는 없으므로(return 문이 없으면 계산 결 과가 없는 것이다) 이는 서브루틴에 해당된다. 반면에 다음 프로그램의 경우에는 ┌────────────────────────────────────────────┐ │ sum(int x, int y) { │ │ return (x+y); │ │ } │ │ │ └────────────────────────────────────────────┘ x+y의 값을 계산 결과로 산출하므로 함수에 해당된다. 함수와 서브루틴은 호출할 때도 차이가 있다. 즉 서브루틴은 다음과 같이 호출 자체만으로(이것으로만) 문장이 된다. ┌────────────────────────────────────────────┐ │ print_hello(); │ └────────────────────────────────────────────┘ 그러나 함수는 다음과 같이 반드시 수식과 같이 사용되어야만(그것도 부수효과가 있는 경우에 만) 문장으로서 의미가 있다. ┌────────────────────────────────────────────┐ │ x = sum(1,3); │ └────────────────────────────────────────────┘ C에서는 서브루틴과 함수를 모두 함수로 취급하기 때문에 다음과 같이 의미 없는 문장들도 가능 하게 된다. ┌────────────────────────────────────────────┐ │ x = print_hello(); │ │ sum(2,4); │ └────────────────────────────────────────────┘ 위에서 print_hello()는 계산 결과가 없는데 이것이 마치 있는 것처럼 x에 값을 할당하고 있다. 이렇게 해도 컴파일할 때나 수행할 때 전혀 에러가 발생하지 않지만 x에는 전혀 예상할 수 없는 값이 들어가기 때문에 주의해야 한다. 그리고 sum(2,4);의 경우에는 일단 계산을 하면 6이 되고 결국 6; 과 같은 수식문이 되어 전혀 쓸모 없는 문장이 되어 버리는데 C에서는 이를 도와주기 위 해 void란 데이터 유형을 제공하고 있다. 즉 함수의 데이터 유형을 다음과 같이 void로 선언하게 되면 ┌────────────────────────────────────────────┐ │ void print_hello() { │ │ printf("Hello!\n"); │ │ } │ │ │ └────────────────────────────────────────────┘ 이 함수는 계산 결과가 없다고 하는 의미가 된다. 따라서 다음과 같이 계산 결과를 사용하려고 하면 ┌────────────────────────────────────────────┐ │ x = print_hello(); │ └────────────────────────────────────────────┘ 컴파일 에러나 경고 메시지가 발생하게 되어 에러를 방지할 수 있다. 따라서 계산 결과가 없는 함수(즉 서브루틴에 해당하는 것들)는 반드시 void로 선언하여야 한다. 지금까지 선언한 main 함 수도 계산 결과가 없을 때에는 다음과 같이 void로 선언하는 것이 정확한 표현이 된다. ┌────────────────────────────────────────────┐ │ void main() { │ │ : │ └────────────────────────────────────────────┘ void 유형은 역시 C에서만 볼 수 있는 특이한 데이터 유형으로 일반 변수에는 사용할 수 없고 함수에만 사용된다. 다음은 void 유형에 관한 예이다. #include void print_char(char c, int n) { int i; for (i = 1; i <= n; i++) printf(" %c",c); } main() { int n; int i; printf("Input N -> "); scanf("%d",&n); for (i = 1; i <= n; i++) { print_char(' ',n - i); print_char('*',2 * i - 1); putchar('\n'); } for (i = 1; i <= n - 1; i++) { print_char(' ',i); print_char('*',2 * n - 2 * i - 1); putchar('\n'); } } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Input N -> 10 뇌 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void print_star(int n) { int i; for (i = 1; i <= n; i++) printf(" *"); } main() { int i, n; printf("Input N -> "); scanf("%d",&n); for (i = 1; i < n; i++) { print_star(i); printf("%d\n",i); } for (i = n; i > 0; i--) { print_star(i); printf("%d\n",i); } } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Input N -> 10 뇌 *1 * *2 * * *3 * * * *4 * * * * *5 * * * * * *6 * * * * * * *7 * * * * * * * *8 * * * * * * * * *9 * * * * * * * * * *10 * * * * * * * * *9 * * * * * * * *8 * * * * * * *7 * * * * * *6 * * * * *5 * * * *4 * * *3 * *2 *1 < RETURN 문 > return 문은 함수 내에서 계산 결과를 산출하여 자신을 호출한 함수에 되돌리는 역할을 하는 문 장으로 다음과 같은 형태로 사용한다. ┌────────────────────────────────────────────┐ │ return; │ │ return (수식); │ └────────────────────────────────────────────┘ return 문 다음에는 변수와 상수는 물론 수식이 올 수 있다. 수식이 올 경우 괄호로 묶어 준다. 그리고 되돌림 값이 void형인 함수에서의 return 문은 그 함수를 중단시키는 역할을 한다. 다음은 return 문의 몇가지 예 이다. ┌────────────────────────────────────────────┐ │ return; /* 단순히 함수를 종료하는 역할을 한다 */ │ │ return (a + b); /* 수식일 경우 괄호로 묶도록 한다 */ │ │ return (i++); /* i 값을 하나 증가시킨 후 값을 되돌린다 */ │ │ return (iabs(n) * 2); /* 다른 함수를 호출하여 return할 수도 있다 */ │ │ │ └────────────────────────────────────────────┘ 다음은 음력 1992년 1월 1일은 수요일이라는 조건하에 그 이후의 년, 월, 일을 입력하면 그 날짜 의 요일을 출력하는 프로그램으로 1992년 1월 1일을 기점으로 지나간 날 수를 계산하면 되는데 윤년이 있으므로 이를 같이 고려하여야 한다. 윤년은 4의 배수인 해인데 100의 배수는 윤년이 아 니고 또 400의 배수는 윤년이다. 각 달마나 날수가 틀리므로 그 달 까지의 날 수를 계산해 주는 함수를 사용하도록 한다. long int compute_days(int y, int m, int d) { /* 1992년 1월 1일을 기준으로 한 날수를 계산 */ long int ds; int i; ds = (y - 1992) * 365l + mdays(y, m) + d; /* 우선 윤년을 빼고 계산 */ for (i = 1992; i < y; i += 4) /* 그 사이의 윤년을 찾아 1씩을 더함 */ if ((i % 400 == 0) || ((i % 100 != 0) && (i % 4 == 0))) ++ds; return (ds); } void print_day(int d) { switch (d) { case 1: printf("The day is Wednesday.\n"); break; case 2: printf("The day is Thursday.\n"); break; case 3: printf("The day is Friday.\n"); break; case 4: printf("The day is Saturday.\n"); break; case 5: printf("The day is Sunday.\n"); break; case 6: printf("The day is Monday.\n"); break; case 0: printf("The day is Tuesday.\n"); break; } } void main() { int year, mon, day; long int days; printf(" Input Year -> "); scanf("%d",&year); printf("Input Month -> "); scanf("%d",&mon); printf(" Input Day -> "); scanf("%d",&day); if (!day_is(year,mon,day)) printf("Incorrect date!!\n"); else { days = compute_days(year,mon,day); print_day((int)(days % 7)); } } day_is(int y, int m, int d) { /* 년, 월, 일이 올바른지 조사하는 함수 */ int e = 0; if (y < 1992 || m < 1 || m > 12 || d < 1 || d > 31) /* 1992년 이전이나 월이 1 ~ 12 사이가 아니거나 일이 1 ~ 31 사이가 아니면 잘못 */ return (0); /* 값이 1이면 올바르며, 0이면 틀림 */ if ((y % 400 == 0) || ((y % 100 != 0) && (y % 4 == 0))) /* 윤년이 계산 */ e = 1; switch (m) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: return (1); case 2: if (d <= 28 + e) /* 2월이고 일수가 28 + 1(윤년의 경우) 보다 작으면 정상 */ return (1); else return (0); case 4: case 6: case 9: case 11: if (d <= 30) return (1); else return (0); } } mdays(int y, int m) { /* 1월 1일을 기준으로 바로 전월까지의 날수를 계산 */ int e = 0; if ((y % 400 == 0) || ((y % 100 != 0) && (y % 4 == 0))) /* 윤년을 계산 */ e = 1; switch (m) { case 1: return (0); case 2: return (31); case 3: return (59 + e); case 4: return (90 + e); case 5: return (120 + e); case 6: return (151 + e); case 7: return (181 + e); case 8: return (212 + e); case 9: return (243 + e); case 10: return (273 + e); case 11: return (304 + e); case 12: return (334 + e); } } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Input Year -> 1995 뇌 Input Month -> 7 뇌 Input Day -> 24 뇌 The day is Monday. 다음은 계산기를 다음과 같이 확장한 프로그램이다. ① 각 숫자는 b, d, o, x로 시작할 수 있다. b로 시작하면 이진수이며 d는 십진수, o는 8진수, x는 16진수이다. 따라서 -d123 + x34는 십진수 -123 과 16진수 34의 합을 의미한다. b, d, o, x가 생략되었을 경우에는 10진수로 가정한다. ② 숫자와 연산자 사이를 나 등으로 띄울 수 있다. 또 숫자 앞에도 나 이 들어갈 수도 있다. 따라서 -127 * o345와 같이 사용할 수 있다. 이 프로그램에서는 scanf를 사용할 수 없다. 숫자 앞에 b, d, o, x라는 문자가 있을 수 있을 뿐만 아니라 나 도 있을 수 있기 때문이다. 따라서 이 경우에는 한자씩 읽어서 이를 숫자로 변환하는 것이 필요한데, 이를 하나의 함수로 만들어 사용하도록 하겠다. 그런데 문제는 한자씩 숫자가 아닐 때까지 읽어 이를 변환하기 때문에 끝의 한자를 더 읽어야 변환이 가능하다 는 것이다. 예를 들어 17*34라고 입력한 경우 17* 까지 읽어야 '*'가 숫자가 아니므로 '1'과 '7' 을 17로 만들 수 있다. 이때 '*'를 이미 읽어 버렸기 때문에 이를 다시 사용할 수 없게 된다. 이 의 해결책은 마지막으로 읽은 것을 취소해 그 다음에 다시 읽어들이도록 하는 것이다. 이를 위한 라이브러리 함수로 ungetc라는 것이 있으며 이는 ungetc(c, stdin)이란 형태로 사용하면 되는데 c 가 취소할 문자가 된다. 또 x의 y승을 계산하여야 하는데 이에 대한 라이브러리 함수로 pow가 있다. pow(x, y)는 x의 y승을 계산하는 것인데 x와 y가 모두 double 유형이기 때문에 이로 변환 하여 호출하는 것이 필요하다. #include /* ungetc(c,stdin) 함수를 사용하기 위해 선언 */ #include /* pow(x,y) 함수를 사용하기 위해 선언 */ long int read_number() { /* 하나의 숫자를 읽음 */ int base = 10; /* 기본 진법은 10진수 */ long int res = 0l; /* 지금까지 읽은 숫자를 기억 */ int sign = 1; /* 기본 부호는 + */ char c; again: while ((c = getchar()) == ' ' || c == '\t'); /* 와 은 무시 */ switch (c) { case 'd': break; /* d로 시작하면 10진수 */ case 'b': base = 2; /* b로 시작하면 2진수 */ break; case 'o': base = 8; /* o로 시작하면 8진수 */ break; case 'x': base = 16; /* x로 시작하면 16진수 */ break; case '+': goto again; /* +면 부호에 변화가 없음 */ case '-': sign *= -1; /* -면 부호가 바뀜 */ goto again; default : ungetc(c,stdin); /* 다른 값이면 입력을 취소 */ } while ((c = getchar()) && (((base != 16) && (c >= '0') && (c - '0' <= base - 1)) || ((base == 16) && (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')))) /* 진법에 맞는 수가 입력되는 동안 */ switch (c) { case 'a': /* 16진수 A */ case 'A': res = res * base + 10l; break; case 'b': /* 16진수 B */ case 'B': res = res * base + 11l; break; case 'c': /* 16진수 C */ case 'C': res = res * base + 12l; break; case 'd': /* 16진수 D */ case 'D': res = res * base + 13l; break; case 'e': /* 16진수 E */ case 'E': res = res * base + 14l; break; case 'f': /* 16진수 F */ case 'F': res = res * base + 15l; break; default : res = res * base + c - '0'; /* 그외는 이와 같이 계산됨 */ } ungetc(c,stdin); /* 하나 더 읽은 것을 취소시켜 다음에 읽도록 함 */ return (res * sign); } void skip_last() { /* 에러가 발생했을 때 나머지 문자들을 읽어 버림 */ while (getchar() != '\n'); } void main() { long int x, y; char op; while (1) { printf("--> "); /* 프롬프트 */ x = read_number(); /* 첫번째 정수를 읽어버림 */ while ((op = getchar()) == ' ' || op == '\t'); /* 연산자나 명령을 읽음 */ if (op == 'q' || op == 'Q') break; y = read_number(); /* 두번째 정수를 읽어버림 */ switch (op) { case '+': printf("%ld\n",x+y); break; case '-': printf("%ld\n",x-y); break; case '*': printf("%ld\n",x*y); break; case '/': printf("%ld\n",x/y); break; case '%': printf("%ld\n",x%y); break; case '^': printf("%.0lf\n",pow((double)x,(double)y)); break; default : printf("Error : Unknown Operator %c\n",op); } skip_last(); } } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- --> b10101010 * 25 뇌 4250 --> Q 뇌 ※ main에서의 return 문 ┌────────────────────────────────────────────┐ │ main() { │ │ return (2); │ │ printf("Hello!\n"); │ │ } │ │ │ └────────────────────────────────────────────┘ return 문은 자신을 부른 함수에게로 돌아가게 만든다고 언급한 바 있는데, main 함수 내에서 return 문을 사용할 경우에도 다른 return 문과 같이 처리된다. 즉 자신을 부른 함수에게 계산 결과를 넘겨주고 자신의 수행은 끝내게 되는데 main이 프로그램의 시작이므로 결국 프로그램의 수행이 끝나게 되어 그 다음의 printf 문은 수행되지 않는다. 그런데 문제는 main을 부른 함수가 없다는 것이다. 이는 바로 OS(즉, 위 프로그램을 수행시킨 운영 체계)에게 전달된다. 예를 들어 MSC나 TC의 경우에는 DOS에 계산 결과가 전달되며 Unix는 Shell에게 계산 결과가 전달된다. 마치 OS가 main을 부른 함수라고 생각하면 되는데 이 OS에게 전달된 값은 OS 상에서 액세스하여 사용 할 수 있다. DOS의 경우에는 배치 화일 상에서 IF ERRORLEVEL == 값 과 같은 형태로 확인하는 것이 가능하다. 예를 들어 위의 프로그램의 수행화일이 test.exe라고 할 때 다음과 같이 배치 화일을 만들고 이 를 수행하게 되면 ┌────────────────────────────────────────────┐ │ @ECHO OFF │ │ TEST │ │ IF ERRORLEVEL == 2 GOTO PRINT │ │ GOTO END │ │ :PRINT │ │ ECHO The result is 2! │ │ :END │ │ │ │ │ │ │ └────────────────────────────────────────────┘ test.exe가 return (2);를 통해 2를 계산 결과로 DOS에 넘겨주므로 ERRORLEVEL == 2는 참이 되 어 다음과 같은 수행 결과를 얻게 된다. ┌────────────────────────────────────────────┐ │ The result is 2! │ └────────────────────────────────────────────┘ main에서의 return 문은 실제로 어떤 계산 결과라기 보다는 이 프로그램이 어떻게 끝났는 지를 알려주는 성격이 더 강하다. 일반적으로 0은 정상적으로 수행이 종료하였음을 의미하며 음수값이 나 0보다 큰 값은 수행이 비정상적으로(즉 에러가 발생했다든지 하여) 끝났음을 의미하는 경우가 많다. 따라서 이 값을 보면 방금 수행한 프로그램의 상태를 알 수 있으므로 이를 바탕으로 다른 프로그램을 수행할 것인지를 판단할 수 있다. 실제 프로그램 상에서 프로그램의 수행을 중단하고 OS에게 돌아가게 할 때에는 exit 문을 더 많이 사용한다. < 인자의 전달 > 인자의 전달이란 실인자의 값이 형식 인자의 값으로 어떻게 전달되는가 하는 것을 의미한다. ┌────────────────────────────────────────────┐ │ void swap(int x, int y) { │ │ int t; │ │ t = x; │ │ x = y; │ │ y = t; │ │ } │ │ │ │ main() { │ │ int x = 10; │ │ int y = 20; │ │ swap(x, y); │ │ printf("x = %d, y = %d\n",x,y); │ │ } │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위의 swap 함수는 x와 y의 값을 서로 바꾸고 있다. 그러면 main 함수에서 swap(x, y)를 호출하 였으니 x와 y의 값이 바뀌어야 할 텐데 위 프로그램을 실제로 수행해 보면 x = 10, y = 20으로 전혀 바뀌지 않았음을 알 수 있는데 이유는 바로 C의 인자 전달 방법 때문이다. C에서는 값에 의 한 호출(call by value) 방법으로 인자를 전달하고 있으며 철저하게 값만 인자로 전달된다. 이 얘 기는 main에서 swap(x, y);로 x와 y를 실인자로 제공하고 있지만 swap(x, y)의 x, y에 전달되는 것은 main의 x, y의 값, 즉 10, 20이 전달된다. 따라서 위의 swap 호출은 swap(10, 20);과 똑같은 의미를 갖게 된다. 그러므로 당연히 swap에서 아무리 x, y의 값을 바꾸어 보았자 main의 x, y의 값은 바뀌지 않는 것이다(swap의 x, y와 main의 x, y는 이름만 같지 전혀 다른 변수이다). 값에 의한 호출이란 실인자를 전달할 때 항상 그 값만을 전달해 준다는 뜻으로 매개변수가 전달 되는 과정을 보다 깊숙이 살펴보면 어떤 함수가 호출되기 전에 매개변수의 값들은 stack이라는 컴퓨터 내부 기억장소에 저장된후 호출된 함수에서는 다시 그 값을 꺼내 사용하는 방식을 취하고 있다. IBM-PC에서는 내부 스택이 정해져있어 주로 함수의 호출 및 매개변수 전달에 쓰이고 있 다. 이러한 스택은 이른바 LIFO(Last In First Out)의 구조를 가지고 있어 가장 최근에 저장된 값이 바로 꺼내질 수 있도록 되어 있다. ※ 함수의 인자 수에 대하여 함수의 인자 수는 고정되어 있는게 보통이다. 그리고 그 인자 수에 맞는 실인자를 함수 호출시 제공하여야 한다. 그런데 C에서는 함수의 인자수 보다 적은 실인자를 제공하거나 더 많은 실인자 를 제공해도 컴파일할 때 전혀 에러가 발생하지 않는다. 예를 들어 다음 프로그램의 경우, ┌────────────────────────────────────────────┐ │ void func(int x, int y) { │ │ printf("x = %d, y = %d\n",x,y); │ │ } │ │ │ └────────────────────────────────────────────┘ 위 함수를 사용하려면 int 유형의 인자를 2개 제공하여야 한다. 그런데 만약 func(1,2,3)으로 3 개를 사용하면 분명히 잘못된 것이지만 이를 실제로 해보면 컴파일시나 수행시 전혀 에러가 발생 하지 않음을 알 수 있다. 그리고 x = 1, y = 2란 출력을 얻게 된다. 즉 알아서 필요한 만큼 가져 간 것이다. 그러면 func(1)과 같이 모자라게 호출하면 어떻게 되겠는가? 역시 이 경우에도 컴파 일시는 전혀 에러가 발생하지 않는다. 그런데 수행시에는 다음과 같이 엉뚱한 결과가 발생하게 된다. ┌────────────────────────────────────────────┐ │ x = 1, y = 0 │ └────────────────────────────────────────────┘ 이는 func에서 무조건 두 개의 int 유형의 인자가 필요하므로 이를 사용하려고 시도해서 첫번째 는 제대로 사용하지만 두번째는 엉뚱한 곳의 것을 사용하기 때문이다. 특히 다음과 같이 함수 호 출시 인자를 괄호로 둘러싸게 되면 ┌────────────────────────────────────────────┐ │ func(1,(2,3)); │ └────────────────────────────────────────────┘ 첫번째 ','는 인자를 구분하는 기호로 인식되지만 두번째 콤마는 콤마 연산자로 인식된다. 따라 서 콤마 연산자를 먼저 계산하기 때문에(이의 계산 결과는 무조건 오른쪽이다) 다음과 같이 호출 한 것과 같은 의미를 갖게 된다. ┌────────────────────────────────────────────┐ │ func(1,3); │ └────────────────────────────────────────────┘ 인자로 복잡한 수식을 사용할 경우 괄호를 사용하는 수가 많은데 위와 같은 실수로 다음 인자까 지 괄호로 둘러쌀 수 있다. 이 경우 잘못된 결과를 얻게 되므로 주의하여야 한다. < 변수의 메모리 유형 > 메모리 유형은 변수의 동작 범위와 존속 기간에 영향을 미친다. 변수의 동작 범위란 그 변수를 프로그램의 어느 부분에서 사용할 수 있는 가에 대한 것으로, 함수 안에서 정의된 변수들은 자신 이 정의된 함수 내에서만 사용할 수 있으므로 그 함수가 동작 범위가 되며, 마찬가지로 블럭 안 에서 정의된 변수들은 그 블럭이 동작 범위가 된다. 존속 기간이란 그 변수를 얼마나 오래 사용 할 수 있는가 하는 것으로, 함수 안에서 정의된 변수들은 그 함수를 호출해서 함수 안의 프로그 램을 수행할 때에만 사용할 수 있으므로 존속 기간이 함수와 같다고 할 수 있다. ⑴ auto 메모리 유형 auto 메모리 유형은 지금까지 사용했던 변수들의 메모리 유형을 의미한다. 따라서 원래는 다음 과 같이 선언하여야 하는데, ┌────────────────────────────────────────────┐ │ main() { │ │ auto int i; /* auto 메모리 유형의 변수들을 지역 변수라고도 한다 */ │ │ auto char c; │ │ : │ │ │ └────────────────────────────────────────────┘ auto를 생략한 것이다(실제로 생략해서 더 많이 사용한다). auto 메모리 유형의 변수들은 우선 동작 범위가 자신이 선언된 함수나 블럭이 된다. 반면에 존속 기간은 함수 안에 정의된 변수들은 그 함수 안에 제어가 있는 동안, 즉 그 함수의 프로그램을 수행하는 동안이 된다. 그리고 그 함수 의 수행이 끝나게 되면 변수들은 사라지게 된다. 마찬가지로 블럭 안에 선언된 변수들은 그 블럭 안에 제어가 있는(그 블럭 내의 프로그램을 수행하는) 동안 살아있게 되며 블럭에서 제어가 떠나 면, 즉 블럭 밖의 프로그램을 수행하게 되면 사라지게 된다. auto 변수의 특징은 프로그램이 컴파일될 때 기억장소가 만들어지는 것이 아니고 프로그램 실행 도중에 그 변수가 선언된 블럭이나 함수가 시작될 때 기억 장소가 할당 되었다가 그 블럭이나 함 수를 떠날 때는 자동으로 메모리에서 제거된다. ⑵ extern 메모리 유형 extern 메모리 유형의 변수들은 함수 안이 아닌 함수 바깥쪽에 정의되며 메모리 유형이 없는 변 수들은 모두 extern 메모리 유형의 변수들이다. extern 메모리 유형의 변수들의 동작 범위는 자신이 정의된 위치부터 프로그램의 끝까지가 된다. 다음은 각 extern 메모리 유형 변수의 동작 범위를 나타낸 것이다. ┌────────────────────────────────────────────┐ │ int i = 100; -------------------------------------------+ │ │ char c = 'A'; | │ │ | │ │ main() { | │ │ int j = i; /* i를 사용 */ | │ │ char d = 'f'; | │ │ d += c - 'e'; /* c를 사용 */ | i와 c의 동작 범위 │ │ proc1(); | │ │ printf("j = %d, d = %c\n",j,d); | │ │ } | │ │ | │ │ int k = 123; ------------------+ | │ │ | | │ │ proc1() { | k의 동작 범위 | │ │ int l = k; /* k를 사용 */ | | │ │ printf("l = %d\n",l); | | │ │ } ---------------------------+ -----------------------+ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 반면 중간에 선언된 extern 메모리 유형의 변수들을 그 앞에서도 사용할 수 있는데 이 경우에는 사용하기 전에 변수를 선언하는 것이 필요하다. 이 선언은 지금까지의 변수의 정의와는 다른 것 으로, 변수를 선언한 경우에는 extern 변수를 어디에 정의하였건 전체 프로그램이 동작 범위가 될 수 있다. 그래서 extern 메모리 유형의 변수들을 전역 변수라고 부른다. 변수 선언만 하면 프로그 램의 어느 부분에서도 사용할 수가 있고, 심지어는 다른 화일의 프로그램에서도 사용할 수 있기 때문이다. extern 메모리 유형의 변수들의 존속 기간은 전체 프로그램의 수행시간이 된다. 즉, 프로그램이 수행되는 동안(프로그램의 어느 부분을 수행하건) 이 변수들은 살아 있어서, 이들 변수의 값을 사 용할 수 있다. 따라서 extern 메모리 유형의 변수들은 각 함수에서 공통적으로 사용하는 변수들로 사용된다. 예를 들어 모든 함수에서 사용해야할 데이터가 있을 경우 이를 extern 메모리 유형의 변수를 이용하여 사용하면 매우 효율적인 프로그램을 작성할 수 있다. 또 함수에서는 자신을 부 른 함수의 데이터를 변경할 수 없으므로 다른 함수들이 변경해야 할 데이터를 extern 메모리 유 형으로 사용하면 함수들이 이를 쉽게 변경할 수 있다. 변수의 선언은 다음과 같은 형태로 사용한다. ┌────────────────────────────────────────────┐ │ extern 데이터 유형 변수 이름; │ └────────────────────────────────────────────┘ 맨 앞에 반드시 extern이라고 붙여야 하며 나머지는 변수의 정의와 같다. 변수를 extern 형으로 선언하는 것은 그 변수가 다른 화일이나 블럭 또는 함수에 존재한다는 것 을 컴파일러에게 알려서 현재의 화일이나 블럭 또는 함수에서 사용할 수 있도록 해주는 것이다. 예를 들어 다음 프로그램의 경우. ┌────────────────────────────────────────────┐ │ main() { ---------------------------------+ │ │ extern int count; | │ │ int i; | │ │ i = count - 5; | │ │ ++count; | │ │ f1(); | │ │ printf("i = %d, count = %d\n",i,count); | count 변수의 동작 범위 │ │ } | │ │ | │ │ int count = 5; | │ │ f1() { | │ │ ++count; | │ │ } ----------------------------------------+ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위 프로그램에서 다음과 같이 main 앞에 count를 정의하면 변수 선언을 할 필요가 없다. ┌────────────────────────────────────────────┐ │ int count = 5; ----------------------------+ │ │ main() { | │ │ int i; | │ │ i = count - 5; | │ │ ++count; | │ │ f1(); | │ │ printf("i = %d, count = %d\n",i,count); | │ │ } | count 변수의 동작 범위 │ │ | │ │ f1() { | │ │ ++count; | │ │ } ----------------------------------------+ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 반면에 반드시 변수 선언을 해야만 하는 경우가 있는데 이는 사용하고자 하는 변수가 다른 화일 에 정의되어 있는 경우이다. ┌────────────────────────────────────────────┐ │ /* main.c */ │ │ main() { │ │ extern int count; -------------------------------+ │ │ int i = 5; | │ │ f1(); | 변수 선언에 따라 새로 생긴 │ │ printf("i = %d, count = %d\n",i,count); | count의 동작 범위 │ │ } -----------------------------------------------+ │ │ │ │ /* f1.c */ │ │ int count = 10; -----+ │ │ f1() { | count의 원래 동작 범위 │ │ ++count; | │ │ } ------------------+ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ count가 extern 메모리 유형의 변수이기 때문에 위외 같이 변수를 선언하면 main에서도 사용할 수 있게 된다. 실제로 변수의 선언은 위와 같이 주로 다른 화일에 정의된 변수를 사용하고자 할 때 사용한다. 그런데 변수 선언시의 데이터 유형과 실제 정의 때의 데이터 유형이 다르면 어떻게 되는가? ┌────────────────────────────────────────────┐ │ main() { /* main.c */ │ │ extern int count; │ │ extern char data; │ │ int i = count; │ │ char c = data; │ │ f1(); │ │ printf("i = %d, c = %c\n",i,c); │ │ } │ │ │ │ char count = 'A'; /* f1.c */ │ │ int data = 300; │ │ f1() { │ │ ++count; │ │ ++data; │ │ } │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ count는 char 유형으로, data는 int 유형으로 정의되어 있다. 그런데 main에서는 이들을 count는 int로, data는 char로 선언하여 사용하고 있는데, 이렇다 하더라도 컴파일시에는 아무런 에러가 나 지 않는다. 이는 컴파일러가 철저하게 화일 단위로 컴파일하기 때문인데 main.c를 컴파일할 때에 는 사용자가 선언한 것을 그대로 믿고 컴파일하며 f1.c에서는 정의한 그대로 컴파일하기 때문이다 (이때 전에 컴파일한 것은 잊어 버린다). 그리고 링크시에도 링커가 아는 것은 오로지 이름 뿐이 다. 따라서 다음과 같이 수행시 아무런 에러 메시지 없이 잘못된 결과가 나오게 되므로 주의해야 한다. ┌────────────────────────────────────────────┐ │ i = 11329, c = , │ └────────────────────────────────────────────┘ extern으로 선언할 변수가 많은 경우에는 위와 같은 실수를 할 수 있는데 이를 방지하는 방법은 별도의 header 화일을 만들어 이를 include 하는 것이다. 그리고 다음과 같이 이중으로 변수를 선언할 수도 있다. ┌────────────────────────────────────────────┐ │ extern int data /* extern으로 변수를 선언하였다고 해서 메모리가 할당 */ │ │ extern char count; /* 되는 것은 아니고 컴파일러에게 이러한 변수가 다른 */ │ │ /* 파일 내에 존재하고 있음을 알려주는 것에 불과하다 */ │ │ main() { │ │ extern int data; │ │ : │ │ } │ │ │ │ f1() { │ │ extern int count; │ │ : │ │ } │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ data와 count를 전역적으로 선언해 놓고 main과 f1 내에서 또 선언하고 있다. 이와 같이 중복되 게 선언하게 되면 이 둘의 선언이(즉 데이터 유형이) 같을 때에는 그냥 무시하고 지나 가지만 다 를 경우에는 에러가 발생하게 된다. 따라서 위의 프로그램의 경우 data는 두 개의 선언이 같기 때문에 별 문제가 없지만 count의 경우에는 전역적으로 char 유형으로 선언하고 f1에서는 이를 다시 int로 선언했기 때문에 컴파일시 에러가 발생하게 된다. ⑶ static 메모리 유형 static 메모리 유형의 변수들은 메모리 유형앞에 static이라고 선언된 변수들을 의미하며 지역 static 메모리 유형과 전역 static 메모리 유형이 있다. 지역 static 메모리 유형의 변수들이란 auto 메모리 유형의 변수들에 auto대신 static이 붙은 변 수들을 의미하는데, 지역 static 메모리 유형의 변수들이나 auto 유형의 변수들이나 별로 차이가 없는 것처럼 보인다. 실제로도 지역 static 메모리 유형의 변수들의 동작 범위는 auto 변수의 경 우와 같이 자신이 정의된 함수나 블럭 내에서만 사용할 수 있다. 그러나 존속 기간의 경우 지역 static 메모리 유형의 변수들은 extern 변수와 같다. 즉 전체 프로그램이 수행 되는 동안 계속해서 살아 있으면서 자신의 값을 유지하게 된다. 다음은 이의 한 예이다. void test() { static int s_count; /* static 메모리 유형은 초기화시키지 않았을 경우 */ int a_count = 0; /* 0의 값을 가진다 */ s_count++; a_count++; printf("static count = %2d\tauto count = %d\n",s_count,a_count); } main() { int i; for (i = 0; i < 10; i++) test(); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- static count = 1 auto count = 1 static count = 2 auto count = 1 static count = 3 auto count = 1 static count = 4 auto count = 1 static count = 5 auto count = 1 static count = 6 auto count = 1 static count = 7 auto count = 1 static count = 8 auto count = 1 static count = 9 auto count = 1 static count = 10 auto count = 1 위 프로그램에서는 test란 함수를 10번 부르고 있다. test 내에는 static 변수 s_count와 auto 변 수 a_count가 정의 되어 있는데 이들의 값을 하나씩 증가시킨 후 출력하고 있다. 그리고 끝나게 되는데, 이 때 auto 변수인 a_count는 사라지지만 static 변수인 s_count는 사라지지 않고 자신의 값을 갖고 있게 된다. 즉 동작 범위는 auto와 같으나 존속 기간은 extern과 같다. static 변수들은 프로그램이 시작될 당시 한번만 초기화 되며 한 번 값을 가지면 그 값을 프로그 램이 끝날 때까지 갖게 되므로 extern 변수와 같이 메모리를 차지하고 있게 된다. 함수 내에 있으면서 자신의 값을 계속 유지해야할 필요가 있는 경우에 static 변수를 사용하면 된다. 전역 static 메모리 유형의 변수들은 extern 메모리 유형의 변수들과 같이 함수 바깥쪽에 정의된 변수들 가운데 메모리 유형이 static이라고 정의된 변수들을 의미한다. 예를 들어 다음 프로그램의 경우. ┌────────────────────────────────────────────┐ │ int i = 10; │ │ static int j = 3; ---------------------------------+ │ │ | │ │ main() { | │ │ int k = 1; | │ │ printf("i = %d, j = %d, k = %d\n",i,j,k); | │ │ proc1(); | │ │ } | j의 동작 범위 │ │ | │ │ char c = 'A'; | │ │ static char d = 'B'; ---------+ | │ │ | | │ │ proc1() { | d의 동작 범위 | │ │ printf("%c%c\n",c,d); | | │ │ } ←------------------------+--------------------+ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 전역 static 메모리 유형의 변수들은 static만 없으면 바로 extern 메모리 유형의 변수들이다. 그 래서 extern 메모리 유형의 변수들과 유사한 성질도 갖고 있는데 존속 기간이 extern 메모리 유 형의 변수들과 같다. 즉 프로그램이 수행되는 동안 계속해서 자신의 값을 갖고 있게 된다. 그러나 extern 메모리 유형의 변수들이 변수 선언이라는 것만 하면 프로그램의 어느 부분에서도 이를 사 용할 수 있었는데 반해, 이 전역 static 메모리 유형의 변수들은 철저하게 자신이 정의된 위치부 터 그 화일의 끝까지가 자신의 동작 범위가 된다. 따라서 그 외의 부분에서는 변수 선언을 해도 이 변수를 사용할 수 없다. 전역 static 메모리 유형은 변수를 다른 함수나 프로그램으로부터 감추는 역할을 한다. ┌────────────────────────────────────────────┐ │ /* main.c */ │ │ main() { │ │ extern int count; │ │ int i = 5; │ │ f1(); │ │ printf("i = %d, count = %d\n",i,count); │ │ } │ │ │ │ /* f1.c */ │ │ static int count = 10; │ │ f1() { │ │ ++count; │ │ } │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 앞에서 언급한 바와 같이 count변수는 f1.c 내에서만 사용할 수 있기 때문에 main.c에서 extern 으로 선언한 count변수는 없는 것이 되며(f1.c의 count 변수는 다른 곳에서는 사용하지 못하므로 없는 것과 마찬가지이다) 링크시 에러가 발생하게 된다. 위에서와 같이 static 으로 선언한 경우 현재 화일에서만 그 변수의 사용을 가능하게 만들어 주 어 같은 이름의 변수가 다른 화일에 존재하여도 간섭을 받지 않는다. ⑶ register 메모리 유형 컴퓨터의 CPU 안에는 레지스터라는 기억장소가 존재한다. 이러한 레지스터들은 CPU가 처리하 는 논리 연산작용에서 일시 기억장소로 쓰이거나 프로그램을 실행해 나가는 과정에서 CPU에게 필요한 중요한 데이터들의 보관 장소로 이용된다. 레지스터는 보통 변수의 기억 장소로 쓰이는 RAM 보다 입출력 속도가 매우 빠르다. IBM-PC의 8086 CPU의 레지스터는 모두 16비트 레지스 터로서 그 중에는 그 값을 바꾸어도 별로 상관 없는 범용 레지스터라는 것들이 존재하는데 그 레 지스터들을 정수형 변수처럼 사용하는 것이 레지스터 변수이다. 아주 자주 쓰이는 변수에 이 레 지스터 변수를 사용할 경우 속도가 매우 빨라진다. 그러나 int형과 unsigned int형만이 레지스터 변수로 사용될 수 있는데 그 이유는 레지스터가 16비트(2바이트)이기 때문이다. 그리고 레지스터 변수로 선언 했다고해서 항상 레지스터 변수가 되는 것은 아니고 레지스터 변수가 되도록 컴파일 러에게 요구하는 정도이다(IBM-PC의 경우 register 변수가 사용할 수 있는 레지스터의 수는 1 ~ 2개 밖에는 되지 않는다). 참고로 TURBO C 에서는 레지스터 변수로 레지스터 SI와 DI를 사용하며, 굳이 레지스터 변수 로 선언하지 않아도 TURBO C 컴파일러는 블럭의 처음에 나오거나 자주 쓰이는 자동변수를 레 지스터 변수로 사용한다. ※ auto와 register의 비교 (MSC나 C++ Version으로 컴파일 해야 한다) #include #include void main(void) { struct dostime_t t1, t2; register int r; int a, k; long int i; printf("\n** register **\n"); _dos_gettime(&t1); printf("start --> %d %d.%d\n",t1.minute,t1.second,t1.hsecond); for (k = 1; k <= 1000; k++) for (r = 1; r <= 30000; r++); _dos_gettime(&t2); printf(" end --> %d %d.%d\n",t2.minute,t2.second,t2.hsecond); i = t2.minute * 60 * 100 + t2.second * 100 + t2.hsecond - t1.minute * 60 * 100 - t1.second * 100 - t1.hsecond; printf("time = %ld milisecs\n",i); printf("\n** auto **\n"); _dos_gettime(&t1); printf("start --> %d %d.%d\n",t1.minute,t1.second,t1.hsecond); for (k = 1; k <= 1000; k++) for (a = 1; a <= 30000; a++); _dos_gettime(&t2); printf(" end --> %d %d.%d\n",t2.minute,t2.second,t2.hsecond); i = t2.minute * 60 * 100 + t2.second * 100 + t2.hsecond - t1.minute * 60 * 100 - t1.second * 100 - t1.hsecond; printf("time = %ld milisecs\n",i); } 다음은 최대 공약수와 최소 공배수를 구하는 프로그램이다. main() { int gcd = 1; int n, m; int min; register int i; /* 카운터 변수를 register로 선언 */ printf("Input N and M -> "); scanf("%d%d",&n,&m); min = n > m ? m : n; /* 둘 중 작은 값을 구함 */ for (i = 2; i <= min; i++) if (n % i == 0 && m % i == 0) /* 두 수를 다 나누면 지금까지의 최대 공약수가 됨 */ gcd = i; printf("GCD : %d\n",gcd); printf("LCD : %ld\n",(long int)m*n/gcd); } 최대 공약수는 위와 같이 구하는 것보다 일반적으로 많이 사용되는 것은 큰 수를 작은 수로 계 속 나누어서 떨어질 때 찾는 것이다. 나누어 떨어지게 만든 수가 바로 최대 공약수가 된다. main() { int gcd; int max; int n, m; int t; printf("Input N and M -> "); scanf("%d%d",&n,&m); gcd = n > m ? m : n; /* 둘 중 작은 값을 구함 */ max = n > m ? n : m; /* 둘 중 큰 값을 구함 */ while (max % gcd != 0) { /* 큰 값을 작은 값으로 계속 나누어 떨어질 때까지 */ t = max; /* 큰 값과 작은 값을 서로 바꿈 */ max = gcd; gcd = t % gcd; } printf("GCD : %d\n",gcd); printf("LCD : %ld\n",(long int)m*n/gcd); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Input N and M -> 270 720 뇌 GCD : 90 LCD : 2160 ※ 변수들의 영역 규칙 동작 범위에 따라 변수를 나누면 메모리 유형에 따라 전역 변수와 지역 변수로 나눌 수 있다. 즉 extern 메모리 유형과 전역 static 메모리 유형의 전역 변수와 auto메모리 유형과 지역 static메모리 유형의 지역 변수로 나눌 수 있는데, 이들 변수들이 서로 같은 이름을 가질 수 있 다. 예를 들어 다음 프로그램의 경우. int i = 1, j = 2; void main() { int i = 3; /* int l = 3; */ int k = 4; i += j + i; /* l += j + l; */ k *= i - j; /* k *= l - j; */ printf("i = %d, j = %d\n",i,j); /* printf("i = %d, j = %d\n",l,j); */ { int i = 5, k = 6; /* int m = 5, n = 6; */ i = ++j; /* m = ++j; */ k = ++i; /* n = ++m; */ printf("i = %d, j = %d\n",i,j); /* printf("i = %d, j = %d\n",m,j); */ } i = f1(j); j = f1(k); printf("i = %d, j = %d\n",i,j); /* printf("i = %d, j = %d\n",l,j); */ } /* 다른 변수는 다른 이름을 사용한다 */ f1(int x) { return (x + ++i - j--); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- i = 8, j = 2 i = 4, j = 3 i = 2, j = 25 프로그램의 한 곳에서 사용할 수 있는 같은 이름의 변수가 여러 개 있으면 가장 가까운 곳에 정 의된 변수만 사용하기 때문에 결국 나머지 변수들은 사용할 수 없다. 위의 프로그램의 경우 main 내에서 바깥쪽의 i는 사용할 수 없으며 블럭 내에서 main의 k는 사용할 수 없다. < 함수의 메모리 유형 > 함수도 변수와 같이 메모리 유형이 있는데 다음과 같이 두 개의 메모리 유형이 있다. ┌────────────────────────────────────────────┐ │ ⑴ extern 메모리 유형 │ │ ⑵ static 메모리 유형 │ └────────────────────────────────────────────┘ 지금까지 함수를 사용하면서 메모리 유형을 사용한 적이 없다. 즉 이를 생략한 것인데 이 경우 이들 함수들은 모두 extern 메모리 유형을 갖고 있는 것이 된다. extern 메모리 유형의 함수들은 실제로 메모리 유형을 지정하지 말아야 하며 지금까지와 같이 생략해서 사용한 함수들이 extern 메모리 유형의 함수들이다. 그러나 static 메모리 유형의 함수들은 다음과 같이 static이라고 분명 히 선언된 함수들을 의미한다. ┌────────────────────────────────────────────┐ │ static int f1(int x) { │ │ : │ │ } │ │ │ └────────────────────────────────────────────┘ static 메모리 유형의 함수는 자신이 정의된 화일 내에서만 불러 사용할 수 있다. 다른 화일의 프로그램에서는 사용할 수 없게 된다. 이는 전역 static 메모리 유형의 변수와 유사한데, static 메 모리 유형의 함수들도 그 화일 내에서만 함수를 사용하고 다른 화일에서는 사용하지 못하도록 막 고자할 때 사용한다. 다음은 이의 한 예이다. ┌────────────────────────────────────────────┐ │ void main() { /* main.c */ │ │ int i = 10; │ │ int s; │ │ s = f1(i); │ │ s += abs(s); │ │ printf("s = %d\n",s); │ │ } │ │ │ │ abs(int i) { /* static abs(int i) { */ │ │ return (i > 0 ? i : -i); │ │ } │ │ /***********************************************************************************/ │ │ │ │ float abs(float x) { /* f1.c */ │ │ return (x > 0.0f ? x : -x); │ │ } │ │ │ │ f1(int i) { │ │ float f = 2.3f; │ │ f *= i - 13.2f; │ │ i = abs(f); │ │ return (i); │ │ } │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위의 프로그램에서 main.c의 main에서 f1.c화일의 f1을 부르고 있으며 그 후 자신과 같은 화일의 함수 abs를 부르고 있다. 그런데 f1.c에도 같은 이름의 함수 abs가 정의되어 있고 f1에서 이를 부 르고 있다. 따라서 한 프로그램 내에 같은 이름의 함수가 두 개 존재하기 때문에 링크시에 에러 가 발생하게 된다. 그러나 abs를 static 메모리 유형의 함수로 정의하게 되면 아무 문제가 발생하 지 않는다(실제로 이 중 하나만 static으로 정의해도 에러는 발생하지 않는다). 반면에 extern 메모리 유형의 함수는 프로그램의 어느 부분에서든지 호출하여 사용할 수 있다. 심지어 그 함수와 다른 화일에 있는 프로그램에서도 함수를 호출하여 사용할 수 있다(이때 함수 를 선언해야만 사용할 수 있는 경우도 있다). 따라서 extern 메모리 유형의 함수의 동작 범위는 전체 프로그램이 된다. < 함수의 선언 > 함수의 선언은 컴파일러에게 자신이 호출할 함수의 정보를 알려주는 역할을 한다. 즉 함수의 이 름과 그 함수가 산출하는 계산 결과의 유형, 인자의 수와 각 인자의 유형등을 알려 줘서 그 후 컴파일러가 그 함수에 대한 호출문을 만났을 때 이 정보를 바탕으로 처리하도록 하는 것이다. 지금까지 함수를 사용한 예를 보면 호출하는 함수 보다 앞에 함수를 정의한 적도 있었고 오히려 뒤에 정의한 적도 있었다. 상당히 불규칙적으로 정의했었는데 실제로 그렇게 정의해야 하기 때문 에 그렇게 한 것이었다. C 컴파일러가 컴파일 도중에 함수 호출문을 만나게 되면 현재까지 처리한 내용 중에 그 함수에 대한 정의가 있는지를 찾는다. 만약 있으면 이를 바탕으로 그 호출문을 처리하게 된다. 즉 그 함 수가 계산 결과로 넘겨주는 것의 유형을 찾아 그대로 오도록 해주고 인자의 유형은 맞는지 조사 하게 된다. 그런데 이 경우는 함수 호출문 보다 함수가 먼저 정의되어 있는 경우이다. 즉 프로그 램 순서상으로 호출될 함수가 호출한 함수 보다 먼저 나타난 경우가 이에 해당된다. 그러나 그 반대일 수도 있는데 이 경우는 호출문을 만났을 때 무조건 그 함수가 int 유형의 값을 계산 결과 로 돌려주는 함수로 간주하여 처리한다. 그리고 계속해서 처리해 나가는데, 뒤에 그 호출될 함수 가 int 유형의 값을 계산 결과로 돌려주는 함수면 아무 문제가 없지만 만약 다른 데이터 유형의 값을 계산 결과로 산출하는 함수일 경우 컴파일 에러가 나게 된다. 따라서 다음과 같은 사실을 알 수 있다. 함수가 int 유형의 값을 계산 결과로 산출하는 경우에는 함수 호출문 보다 앞에 와도 좋고 뒤에 와도 좋지만, int 유형이 아닌 다른 데이터 유형을 산출하 는 경우에는 함수 호출문 보다 앞에 와야 한다. 지금까지의 함수들은 바로 이 규칙에 따라 작성 되었다. 그래서 int 유형을 계산 결과로 산출하는 함수들은 main 다음에 왔었고 그렇지 않은 함 수들은 main 보다 앞에 왔었다. 만약 함수가 다른 화일에 있는 경우에도 그 함수가 int 유형의 값을 계산 결과로 산출하는 함수 라면 수행시 아무 문제가 없지만 그렇지 않은 경우에는 수행시 잘못된 결과가 나오게 된다. 이를 방지해 주는 것이 바로 함수의 선언으로 다음과 같은 형태로 사용한다. ┌────────────────────────────────────────────┐ │ extern int f1(int x, int y); │ │ float f2(float, int); │ │ extern f3(); │ │ long int f4(void); │ │ extern void f5(int, int, ...); │ │ │ │ │ └────────────────────────────────────────────┘ 위에서 첫번째는 int 유형의 값을 계산 결과로 산출하는 함수 f1을 사용하겠음을 컴파일러에게 알려주고 있다. 이의 인자는 2개가 있는데 둘 다 int 유형이라는 것도 알려주고 있다. 두번째는 float 유형의 데이터를 계산 결과로 산출하는 함수 f2를 선언하고 있는데 역시 인자는 2개이고 첫번째는 float 유형이고 두번째는 int 유형이라고 컴파일러에게 알려 주고 있다. 그러나 세번째는 단순히 f3이 int 유형의 값을 계산 결과로 산출한다고만 알려주고 있는데, 이 함수의 인자가 몇 개가 있는지는 나타나 있지 않다. 따라서 컴파일러는 계산 결과만 조사하게 되 며 인자는 신경쓰지 않게 된다. 반면에 네번째 경우에는 f4가 long int 유형의 값을 계산 결과로 산출하고 인자는 없다고 확실히 선언하고 있다. void는 인자가 없음을 의미하는데, 그 후에 f4를 호출하면서 여기에 인자를 주게 되면 컴파일러는 잘못된 것으로 인식하여 에러 메시지를 내게 된다. 마지막 다섯번째는 f5가 계산 결과가 없는 함수인데 처음 두 개의 인자는 int 유형이여야 하고 그 다음의 인자는 가변적임을, 즉 인자가 더이상 없을 수도 있고 3개가 올 수도 있고 10개가 올 수도 있고 또는 100개 올 수도 있음을 나타낸다. 이는 맨 끝의 '...'이 나타내고 있으며, 따라서 f5 는 printf와 같이 가변 인자 함수임을 알 수 있다. 함수의 선언은 컴파일러에게 정보를 가르켜 주는 것이 주 목적이기 때문에 인자의 이름은 전혀 중요하지가 않다. 그래서 이를 생략하여 위의 두번째 예와 같이 데이터 유형만 줄 수 있다. 또 인 자의 이름을 준다 해도 그 이름이 실제 함수 정의시의 형식 인자의 이름과 같을 필요도 없다. 단 지 함수 정의와 비슷하게 함수를 선언하도록 구색을 맞춘 것에 불과하다. 함수의 선언은 변수의 선언과 같이 함수나 블럭 안에 실행문이 오기 전에 하거나 아니면 함수 바깥쪽에 할 수 있는데, 이때 변수 선언과 같이 동작 범위, 즉 그것의 효력의 범위가 달라지게 된 다. 함수나 블럭 내에 온 경우에는 그 함수나 블럭 내에서만 효과가 있다. 따라서 그 함수나 블럭 을 벗어나게 되면 컴파일러는 이에 대한 정보를 잊게 되어 함수를 선언하지 않은 것과 같은 효과 를 내게 된다. 반면에 함수 바깥쪽에 선언한 경우에는 그 위치부터 그 화일의 끝까지 효력을 유 지하게 된다. 예를 들어 다음 프로그램의 경우. void print_head(); /* 함수의 원형을 선언한다 */ main() { int i, n = 100; print_head(); for (i = 2; i <= n; i++) if (prime(i)) printf("%3d ",i); printf("\n"); } void print_head() { printf("=========================================================="); printf("=====================\n"); printf(" Prime Number from 1 to 100\n"); printf("=========================================================="); printf("=====================\n"); } int prime(int n) { int i; if (n % 2 == 0) return (n == 2); /* 짝수이고 2가 아니면 0을 되돌림 */ if (n % 3 == 0) return (n == 3); /* 3의 배수이고 3가 아니면 0을 되돌림 */ if (n % 5 == 0) return (n == 5); /* 5의 배수이고 5가 아니면 0을 되돌림 */ for (i = 7; i * i <= n; i += 2) /* 소수임을 확인 */ if (n % i == 0) /* i의 배수 이면 0을 되돌림 */ return 0; return 1; /* 위의 모든 경우가 아닐 경우 소수이다 */ } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- =============================================================================== Prime Number from 1 to 100 =============================================================================== 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 ※ 함수의 선언 내용과 실제 함수의 정의 내용이 다를 경우 변수의 선언과 마찬가지로 함수의 정의가 함수를 선언한 것과 같은 화일에 있는 경우에는 컴파 일러가 이 둘이 다름을 인식할 수 있으므로 컴파일시 에러가 나게 된다. 그러나 서로 다른 화일 에 있는 경우에는 컴파일러가 이 둘이 차이가 있다는 것을 모르기 때문에 선언한 대로 호출문을 컴파일하게 되어 결국 수행시 잘못된 결과가 나오게 된다. 또 변수의 선언과 같이 같은 함수를 여러 번 중복되게 선언할 수도 있다. 예를 들어 함수 바깥쪽에 전역적으로 선언해 놓고 함수 안 에서 또 선언할 수도 있다. 이 경우 두 선언이 같거나 충돌의 소지가 없으면(즉 한 선언에서는 인자를 명시하지 않았는데 다른 선언에서는 인자를 명시한 것과 같이) 그냥 무시하지만 다르거나 충돌의 소지가 있으면 역시 에러 메시지를 내게 된다. < 되부름 함수 > 되부름 함수란 자기자신을 다시 호출하는 함수를 일컫는데 자기가 자기 자신을 부르는 것을 재 귀적 호출(recursive call) 또는 리커젼(recursion)이라고 한다. 다음은 하나의 문장을 입력받아 거꾸로 출력해 주는 프로그램이다. #include void print_back() { int ch; if ((ch = getchar()) != '\n') /* 한글자를 입력받고 줄바꿈 문자인지 확인 */ print_back(); /* 줄바꿈 문자가 아닌경우 되부름 */ putchar(ch); /* 입력받은 문자 표시 */ } main() { printf("Enter a line -> "); print_back(); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Enter a line -> Hello 뇌 olleH +-----+ +-----+ Hello\n------6| \n | | \n |1------ \nolleH ||||| +-----+ +-----+ ||||| ||||+--------5| o | | o |2---------+|||| |||| +-----+ +-----+ |||| |||+---------4| l | | l |3----------+||| ||| +-----+ --------------> +-----+ ||| ||+----------3| l | | l |4-----------+|| || +-----+ +-----+ || |+-----------2| e | | e |5------------+| | +-----+ +-----+ | +------------1| H | | H |6-------------+ +-----+스택에 쌓여 올라감 +-----+ 위부터 꺼내서 출력됨 우선 print_back() 함수를 보면 하나의 문자를 입력받아 그 아스키 코드를 정수형으로 되돌리는 함수인 getchar() 함수를 호출하여 ch에 대입한 후 그 값이 줄바꿈 문자가 아니면 다시 되부름 호출을 한다. 이렇게 계속 나가다가 줄바꿈 문자를 만난 시점에서 되부름 호출을 하지 않고 putchar(ch)를 실행하여 화면에 하나의 문자를 표시하는 과정을 문장의 처음까지 반복하게 되어 문자가 거꾸로 찍히게 된다. 다음은 재귀적 호출을 사용하여 N!을 구하는 프로그램이다. ┌────────────────────────────────────────────┐ │ long int fact(int n) { │ │ if (n <= 1) │ │ return (1); │ │ else │ │ return (n * fact(n - 1)); │ │ } │ │ │ │ main() { │ │ int num; │ │ for (num = 1; num <= 10; num++) │ │ printf("%2d! = %8ld\n",num,fact(num)); │ │ } │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위에서 fact함수를 보면 형식인자 n의 값이 1과 같거나 작을 경우 1을 되돌리고 그렇지 않을 경 우에는 n과 fact함수에 n - 1의 값을 다시넣어 호출한 값을 되돌린다. 이 되부름 함수를 다시 차근차근 따져보면, 'fact(1)'로 호출했을 경우에는 처음의 if문에 걸려 1 을 되돌리는 것이 전부이며 'fact(2)'로 호출했을 경우에는 '2 * fact(2 - 1)'을 되돌리게 되는데 fact(1) = 1이므로 결국 2를 되돌린다. 이러한 식으로 'fact(3) = (3 * fact(3 - 1)) = (3 * (2 * fact(2 - 1))) = (3 * (2 * 1))) = 6이 된다. double power(int x, int y) { return ((y == 0) ? 1 : x * power(x, y - 1)); } main() { int x = 10, y; double d; for (y = 15; y <= 20; y++) { d = power(x,y); printf("%2d ^ %2d = %21.0lf\n",x,y,d); } } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- 10 ^ 15 = 1000000000000000 10 ^ 16 = 10000000000000000 10 ^ 17 = 100000000000000000 10 ^ 18 = 1000000000000000000 10 ^ 19 = 10000000000000000000 10 ^ 20 = 100000000000000000000 ※ 되부름 함수는 스택이라는 메모리를 매우 많이 소비한다. 특히 지역변수인 자동변수가 많은 되부름 함수일 경우 더욱 많은 메모리를 사용한다. 실행중 너무 많은 되부름으로 인해 컴퓨터가 작동을 중지하거나 프로그램에 이상이 생기는 수가 발생할 수도 있다. 이러한 단점 외에도 되부 름 함수를 사용함으로써 보통 함수를 사용했을 때보다 더 속도가 느려지거나 프로그램을 이해하 기 어려운 상태로 만들어 버리는 경우가 있다. ※ 다음은 입력한 텍스트 가운데 다음과 같은 스트링이 몇번 나타나는지를 계산하는 프로그램이 다. ┌────────────────────────────────────────────┐ │ if, the, who, while, do, text, tree │ └────────────────────────────────────────────┘ 이 경우 찾는 스트링이 i, w, d, t로만 시작하므로 맨 처음 글자가 i, w, d, t일 경우만 신경쓰 면된다. 만약 if를 찾을 경우, 입력한 글자가 i였을 때 그 다음 글자가 f이면 이는 if가 온 것이 므로 if의 갯수를 기억하고 있는 변수 값을 증가시키면 된다. 이때 입력한 글자가 i인 것을 하나 의 상태라고 하면 이 상태에서 입력이 f가 들어오면 if의 카운터를 증가시키고 다시 처음으로 가 면 되고 그 외의 다른 입력이 들어오면 다시 처음 상태로 가면 된다. 이를 그림으로 나타내면 다 음과 같다. ┌────────────────────────────────────────────┐ │ 모든 입력 │ │ +--------------------------------------------------+ │ │ | 그외의 입력 | │ │ | +-----------------------+ | │ │ | | i | f | │ │ S0 ---------------------> S1 ---------------------> S2 if의 카운터 증가 │ │ │ │ │ └────────────────────────────────────────────┘ 위에서 S0은 처음 상태이며 여기서 i가 들어오면 S1의 상태로 감을 의미한다. S1상태에서 f가 들 어오면 S2는 if의 상태가 되며 그 외의 다른 입력이 들어 오면 다시 S0의 상태로 가게 된다. S2의 상태에서는 무조건 if의 카운터를 증가시키게 되며 그리고 역시 무조건 S0으로 가게 된다(이는 if가 입력되었기 때문이다). 이와 같은 방법으로 위의 7개 스트링(if, who, while, do, the, text, tree)에 대해 상태 전이 다이어그램(state transition diagram)을 작성하면 다음과 같이 된다. ┌────────────────────────────────────────────┐ │ i f │ │ S0 -------> S1 -------> S2 [if발견] │ │ | w h o │ │ +--------> S3 -------> S4 -------> S5 [who발견] │ │ | | i l e │ │ | +--------> S6 -------> S7 -------> S8 [while발견] │ │ | d o │ │ +--------> S9 -------> S10 [do발견] │ │ | t h e │ │ +--------> S11 -------> S12 -------> S13 [the발견] │ │ | e x t │ │ +-------> S14 -------> S15 -------> S16 [text발견] │ │ | r e e │ │ +-------> S17 -------> S18 -------> S19 [tree발견] │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 위에서 없는 입력은 모두 S0으로 가며 이는 그림에 나타나 있지 않다. 다음은 이것을 프로그램으로 옮긴 것이다. #include void main() { char c; int ifno = 0; int whono = 0; int whileno = 0; int dono = 0; int theno = 0; int textno = 0; int treeno = 0; int status = 0; /* 현재의 상태 */ while ((c = getchar()) != EOF) { switch (c) { case 'i': if (status == 0) status = 1; else if (status == 4) status = 6; else { ungetc(c,stdin); status = 0; } break; case 'f': if (status == 1) ++ifno; status = 0; break; case 'w': if (status == 0) status = 3; else { ungetc(c,stdin); status = 0; } break; case 'd': if (status == 0) status = 9; else { ungetc(c,stdin); status = 0; } break; case 't': if (status == 0) status = 11; else if (status == 15) { ++textno; status = 0; } else { ungetc(c,stdin); status = 0; } break; case 'h': if (status == 3) status = 4; else if (status == 11) status = 12; else status = 0; break; case 'o': if (status == 9) ++dono; else if (status == 4) ++whono; status = 0; break; case 'l': if (status == 6) status = 7; else status = 0; break; case 'r': if (status == 11) status = 17; else status = 0; break; case 'x': if (status == 14) status = 15; else status = 0; break; case 'e': if (status == 7) { ++whileno; status = 0; } else if (status == 12) { ++theno; status = 0; } else if (status == 11) status = 14; else if (status == 14) status = 15; else if (status == 17) status = 18; else if (status == 18) { ++treeno; status = 0; } else status = 0; break; default : status = 0; } } printf(" Number of if: %d\n",ifno); printf(" Number of who: %d\n",whono); printf("Number of while: %d\n",whileno); printf(" Number of do: %d\n",dono); printf(" Number of the: %d\n",theno); printf(" Number of text: %d\n",textno); printf(" Number of tree: %d\n",treeno); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- C:\TC>test < test.c 뇌 Number of if: 24 Number of who: 4 Number of while: 5 Number of do: 4 Number of the: 4 Number of text: 4 Number of tree: 4