8. 전처리기와 매크로 함수

8-1. 전처리기(pre-processor)

- 전처리기란 원시파일을 컴파일하기 좋도록 "가공"하는 작업이라고 할 수 있다. 구체적으로 말하면 전처리기는 원시파일 내의 모든 전처리기 지시자를 컴파일할 수 있는 C의 문장으로 전개하는 작업을 담당하고 있다.

 (1) 매크로 전개    : #define과 #, ## 연산자
 (2) 외부 파일 포함 : #include
 (3) 조건부 컴파일  : #if, #ifdef, #ifndef, 
                      #else, #elif, #endif 
                      와 defined 연산자   
 (4) 기타           : #error, #line, #, #undef, #pragma   

#define printexpr1(expr) printf("expr=%d\n",expr)
#define printexpr2(expr) printf(#expr "=%d\n",expr)
#define x_n(x,n) (x##n)
void main()
{
   int x1,x2;
   
   printexpr1(3+1);
   printexpr2(3+1);
   x_n(x, 1)=100;
   x_n(x, 2)=200;
 
   printf("%d, %d",x1,x2);
}

<전개된 후>

void main()
{
     int x1,x2;
     printf("expr=%d\n"3+1);      /* 매크로가 전개되지 않음 */
     printf("3+1" "=%d\n",3+1);      /* 매크로가 전개됨 */
 
     (x1)=100;
     (x2)=200;
 
     printf("%d, %d",x1,x2);
}

① 매크로 전개

(1) #define 문은 매크로 상수나 매크로 함수를 정의하는데 사용된다.

매크로 상수의 정의방법은 다음과 같다.

  #define <대표문자> <바뀌는 문자>

  
    
예) #define PI 3.14159      
    
#define EOF (-1)

이처럼 #define 문을 사용한 매크로 상수는 기억하기 힘든 수치나 데이터들을 알아보기 쉽게 만들어 준다.

(2) 원래 문자 상수나 문자열 상수 안에서는 매크로가 전개되지 않는다. 그러나 # 연산자를 써서 문자열 내에서 매크로가 전개되는 것과 같은 효과를 얻을 수 있다. 단, # 연산자는 #define 문에서만 쓰이고, 그외엔 전혀 쓰지 못한다.

Turbo-C는 문자열 상수를 쓰는데 있어서 특별한 기능을 제공하는데, 그 기능이란 문자열 단위가 연속적으로 나열되어 있으면 전체로서 하나의 문자열 상수로 인식한다는 것이다.

문자열 단위 사이에 공백문자, 탭문자, 개행문자, 주석문 등이 있어도 상관없이 인식한다.

이제 위의 예제 프로그램을 살펴보자.

printexpr1() 함수는 문자열 내에서 매크로가 전개되지 않았지만, printexpr2() 함수는 # 연산자를 써서

   (#expr "=%d\n", expr) ==  ("3+1" "=%d\n", expr) == ("3+1=%d\n", expr)

과 같은 과정을 거쳐 문자열 내에서 매크로가 전개되는 것과 같은 효과를 나타내었다. 실제로 # 연산자는 실매개 변수를 그대로 문자열로 만들어주는 역할을 한다. 그러므로, # 연산자의 기능과 Turbo-C의 문자열에 대한 특별한 기능을 적절히 이용하여 문자열 내에서의 매크로 전개와 같은 기능을 구현한 것이다.

(3) 전처리기가 ## 연산자를 만나면 ## 연산자와 그 양쪽에 있는 공백문자를 모두 제거해 버린다.

따라서 ## 연산자 양쪽을 서로 결합하는 효과를 가져온다.

② 외부파일 포함

 [1] #include 
 [2] #include "sys/stat.h"
 [3] #define HEADER "extgraph.h"
     #include HEADER

#include 문의 사용형태 3가지를 보였다.

#include 문에는 헤더파일의 경로를 포함시킬 수도 있고, 매크로 상수를 써서 헤더 파일명을 지정할 수도 있다. 포함되는 외부파일은 C의 문법에 맞는 내용의 텍스트 파일이면 아무것이나 가능하다.

③ 조건부 컴파일

조건부 컴파일이란, 말 그대로 특정한 조건이 성립될 때나 또는 성립되지 않을 때에만 지정된 범위내의 문장을 컴파일하거나 또는 그냥 무시하고 컴파일하지 않는 것을 말한다.

조건부 컴파일의 주목적은 프로그램의 호환성을 높이는 데 있다. 조건부 컴파일의 실례는 표준 헤더파일에서 가장 많이 찾아볼 수 있다.

조건부 컴파일을 위한 전처리기 지시자는 #if, #ifdef, #ifndef, #else, #elif, #endif 등 모두 6가지가 있고, 그밖에 특별히 defined 라는 전처리기 지시자가 지원된다.

void main()
{
   #if defined(__TINY__)    /* TINY 메모리 모델일 경우 다음 한 줄만 컴파일 */
      printf("This is TINY memory model\n");
   #elif defined(__SMALL__) /* SMALL 메모리 모델일 경우 다음 한 줄만 컴파일 */
      printf("This is SMALL memory model\n");
   #else                    /* 그 외의 메모리 모델일 경우 다음 한 줄을 컴파일 */
      printf("Other memory model\n");
   #endif
}

위의 예제를 살펴보자. 다음과 같은 형식으로 되어있다. 이것은 if-else 문과 비슷해 보인 다. 사실 하는 역할은 비슷하다. #elif 문과 #else 문은 생략가능하다.

 #if 상수수식1
        문장1
 #elif 상수수식2  
        문장2
 #else  문장3
 #endif

#if 문은 상수수식1이 참이면 문장1을 컴파일하고, 거짓이면 문장1을 컴파일하지 않는다.

#elif 문은 상수수식1이 거짓인 경우 상수수식2를 평가하여 참이면 문장2를 컴파일하고, 거짓이면 문장2를 컴파일하지 않는다.

#else 문은 상수수식1과 상수수식2가 모두 거짓인 경우 문장3을 컴파일한다. 만약 상수수식1이나 상수수식2 중 어느 하나라도 참이면 문장3은 컴파일되지 않는다.

#endif 문은 #if 문의 끝을 나타내며, 빠뜨리면 안된다.

defined 연산자는 defined (매크로형) 처럼 쓰이는데, 매크로가 정의되어 있으면 논리적 참(값은 1)으로, 정의되어 있지 않으면 논리적 거짓(값은 0)으로 평가한다.

다음 예제를 보자. #ifndef 문을 사용하였다.

ifndef 는 IF Not DEFine 의 약자이고, ifdef 는 IF DEFine 의 약자이다.

TRUE 같은 일상적인 define 문은 다른 곳에서 사용되었을 수도 있다. 같은 define을 두 번 하게 되면 에러가 나므로, TRUE가 define되지 않았을 경우에만 define을 하게 한다.

다음은 논리적으로 동일하다.

               #ifdef   MACRO  ==  #if  defined (MACRO)
             #ifndef  MACRO  ==  #if !defined (MACRO)

다음의 예제는 #ifdef 문을 이용하여 조건부 컴파일을 함으로서, 디버깅시 유용하다는 단적인 예를 보이고 있다.

#define DEBUG
 
void func(int a, int b)
{
   int c;
 
   c=(a++)+(b++);
   #ifdef DEBUG
      printf("i=%d, j=%d, c=%d\n",a,b,c);
   #endif
 }
 
void main(void)
{
   int i,j;
 
   #ifdef DEBUG
      printf("i=%d, j=%d\n", i, j);
   #endif
   i=5; j=8;
   func(i, j);
}

DEBUG 라는 매크로 상수가 정의되었을 경우에만 함수에서 각 변수들의 값을 출력한다. 이러한 방법은 변수들의 변화를 추적할 수 있게 해주고, 버그를 모두 잡은 후 맨 위의 #define DEBUG 라는 줄을 없애줌으로써 중간중간에 디버그를 위해 존재했던 부분들은 컴파일되지 않고 실행파일이 만들어진다.

물론, 통합 환경의 watch 창을 이용하면 이러한 기능이 필요없다.

④ 기타 전처리기 지시자

(1) #error

- 사용법은 다음과 같다. 에러메시지에 큰따옴표는 쓰지 않는다.

#error 에러메시지

전처리기가 #error 문을 만나면 그 즉시 컴파일을 중단하고, 사용자가 지정한 에러메시지를 내보내는데, 전처리기는 #error 문 다음의 공백을 제외한 첫문자부터 에러메시지로 인식한다.

(2) #line

- 사용법은 다음과 같다.

#line 라인번호 "파일명" 또는 #line 라인번호

#line 문은 기정의 매크로상수 __LINE__ 과 __FILE__ 을 각각 라인번호와 파일명으로 바꾼다. 파일명을 생략하면 __FILE__ 은 바뀌지 않는다.

#define MACRO
#ifdef MACRO
#line 0 "direct.c"  /* MACRO 가 정의되어 있을때만 컴파일됨 */
#endif
 
void main(void)
{
   printf("Line : %d, Filename : [%s]\n",__LINE__,__FILE__);
   #line 100 "main.c"
   printf("Line : %d, Filename : [%s]\n",__LINE__,__FILE__);
}
 
(예상 결과)
Line : 5, Filename : [DIRECT.C]
Line : 101, Filename : [MAIN.C]
 
(실제 결과)
Line : 8, Filename : [C-TEST4.C]
Line : 10, Filename : [C-TEST4.C]

(설명)

#line, __LINE__, __FILE__ 의 사용법을 보인 예이다.
이 파일의 이름은 C-TEST4.C 이다.
실제로 결과는 예상과 전혀 다르게 나왔다.
#line 지시자가 전혀 효과가 없는 것이다.
아마 Turbo-C 2.0의 버그인 듯하다.

(3) 널 지시자 #

- 널 지시자 # 는 구두점 # 가 단독으로 쓰인 것이며, 아무것도 하지않고 전처리기에 의해서 그냥 무시된다. 널 지시자가 쓰인 곳은 라인에 포함되지 않아 __LINE__ 상수에 라인으로 인식되지 않는다.

(4) #undef

- #undef 는 #define 문에 의해 정의된 매크로를 취소하는 역할을 한다.

(5) #pragma

- 컴파일시 각종 옵션을 주는 기능을 하는 것인데, 자세한 내용은 User's Guide나 Turbo C Programmer's Guide의 내용을 참고하면 된다.

1. #pragma inline

   - 이 명령어는 명령행 컴파일러 옵션 중 -B 옵션과 같은 기능을 하는데, 컴파일러에게 소스 프로그램에 인라인 어셈블리가 있다는 것을 알려주는 것이다.

   인라인 어셈블리란 C 소스 프로그램 안에 일부 루틴을 빠른 속도로 처리하기 위해 어셈블리 코드를 직접 사용하는 것을 말한다.

   이와 같은 경우 파일의 선두에 #pragma inline 과 같은 라인을 둠으로써 컴파일러에게 알릴 수 있다.

   Turbo-C 통합환경 내에서는 인라인 어셈블리가 들어간 소스는 컴파일 할 수 없으며, 명령행 컴파일러로 컴파일을 해야 한다. C++에서는 통합환경 내에서도 컴파일할 수 있다.

2. #pragma warn

   - 이것은 컴파일시 발생하는 경고 에러(warning error)를 제어하는 지시자이다. 그 형식은 다음과 같다.

                           #pragma warn +xxx
                        #pragma warn -xxx
                            #pragma warn .xxx    

3. #pragma savereges

   - 이는 huge 함수가 실행되었을 때, 어떤 레지스터의 값도 바뀌지 않게 하기 위한 것이다. 이것은 때때로 어셈블리 언어 코드와 인터페이스 하고자 할 때 요구된다. 이 지시자는 함수의 정의부분 바로 위에 선언해 두어야 한다.

8-2. 기정의 매크로 상수

- Turbo-C 2.0 에는 다음과 같은 15개의 기정의 매크로 상수가 있다. 기정의 매크로 상수는 프로그래머가 직접 #define문으로 정의해주지 않아도 이미 정의되어 있는 매크로 상수들이다.
이 매크로 상수들은 #define문이나 #undef문에 쓰일 수 없다. 따라서 프로그램 내에서 참조만이 가능하고 수정은 불가능하다. 다만 __FILE__ 과 __LINE__ 만은 #line문을 써서 변경할 수 있다. (Turbo-C 2.0에서는 버그로 인해 변경이 되지 않는다.)

  1) __LINE__   : 전처리기가 수행하는 현재 라인의 번호
  2) __FILE__   : 전처리기가 수행하는 파일의 이름
  3) __DATE__   : 전처리기가 수행하는 파일이 만들어진 날짜
  4) __TIME__   : 전처리기가 수행하는 파일이 만들어진 시간
  5) __STDC__   : 컴파일시 ANSI 옵션을 주면 이 상수는 1로 정의되고,
                 그렇지 않으면 정의되지 않는다.
  6) __TURBOC__ : Turbo-C의 버전을 16진수로 나타낸다.
                 Turbo-C 2.0 에서는 버그로 인해 0x18d 라는 이상한 수가
                 출력된다.
  7) __PASCAL__ : 컴파일시 -p 옵션을 주면 1로 정의되며, 그렇지 않으면
                 정의되지 않는다.
  8) __CDECL__  : __PASCAL__ 과 반대로 컴파일시 -p 옵션을 주지 않으면
                 1로 정의되며, 그렇지 않으면 정의되지 않는다.
  9) __MSDOS__  : 모든 컴파일에 대해서 1이라는 상수를 제공
 10) __TINY__       --+
 11) __SMALL__        |   현재의 메모리 모델을 정의하는 상수
 12) __MEDIUM__       |   메모리 모델에 따라 하나의 상수만이 1로 정의됨
 13) __COMPACT__      |
 14) __LARGE__        |
 15) __HUGE__      ---+

8-3. 매크로 함수

A) 매크로 함수에 대해...

- #define문을 이용하여 함수와 같은 기능을 하는 것을 만들 수 있다. 이렇게 '함수와 같은 기능을 하는 것'이라고 말하는 이유는 엄격히 말해서, 매크로 함수는 함수가 아니고 단지 함수와 비슷하게 사용되기 때문이다.

다음은 매크로 함수의 작성 예이다.

   #define MAX(x,y) ((x)>(y) ? (x) : (y))   /* 최대값을 구하는 매크로 함수 */
   #define ABS(x) ((x)<0 ? -(x) : (x))      /* 절대값을 구하는 매크로 함수 */
   #define SQR(x) ((x)*(x))                 /* 제곱값을 구하는 매크로 함수 */
   #define UPCASE(c) (( (c)>='a' && (c)<='z') ? (c)-('a'-'A') : (c) )
           /* 소문자를 대문자로 바꾸는 매크로 함수 */       
   #define LOCASE(c) (( (c)>='A' && (c)<='Z') ? (c)+('a'-'A') : (c) )
           /* 대문자를 소문자로 바꾸는 매크로 함수 */

- 아스키 코드 상에서 문자의 위치를 보면 대문자가 먼저 있고, 그 뒤에 연속적으로 소문자가 나열되어 있다. 대문자를 소문자로, 또는 소문자를 대문자로 바꾸는 것은 다음 연산에 의해서 해결할 수 있다.

         * 소문자 -  대문자 : (소문자) - ('a'-'A')
        * 대문자 -  소문자 : (대문자) + ('a'-'A')

이 연산의 원리는 소문자를 대문자로 바꾸는 경우 그 소문자에, 소문자와 대문자의 차이에 해당하는 수를 빼줌으로써 대문자로 만들 수 있다는 것이다.

왜냐하면 아스키 코드는 뒤로 갈수로 수가 커지고, 대문자보다 소문자가 뒤쪽에 위치하기 때문에 그 차이만큼의 수를 빼주면 대문자의 아스키 코드가 되기 때문이다.

다음은 이것을 이용해서 실제로 작성된 매크로 함수이다.

          #define UPCASE(c) (c)-('a'-'A')
         #define LOCASE(c) (c)+('a'-'A')

그런데, 만약 입력되는 문자가 대문자도 소문자도 아닌 경우엔 엉뚱한 결과가 나오게 된다.

그러므로 그러한 경우에는 그 문자를 그대로 출력하게 만들면 된다. 그 결과 완전하게 만들어진 매크로 함수는 위의 매크로 함수의 예에 나와있다.

B) 매크로 함수 정의시 주의할 점

① 매크로 함수에 사용되는 모든 인자에는 반드시 괄호를 해두는 것이 안전한 정의방법이다. 예를 들어 다음의 매크로 함수를 보자.

이 경우 괄호를 사용하지 않고 정의한 것으로, 부작용이 발생한 것이다. 위 매크로 함수의 전개 후를 보면 알겠지만, 결과는 예상했던 21이 아니라 11이 나온다. 이러한 부작용을 방지하기 위해 가능하면 모든 인자에 괄호를 해두는 것이 좋다.

② 매크로 함수 내에서는 단일 연산자인 증가 연산자(++) 또는 감소 연산자를 사용하지 않는 것이 좋다. 다음의 예를 보자.

#define SQR(x) ((x)*(x))

        
void main()
        
{        
        
int i=2;        
        
printf("%d\n", SQR(++i));

}

이렇게 매크로 함수 SQR()을 정의하고, 매개변수로 ++i 를 주었을 때 전개 결과는 다음과 같다.

              printf("%d\n", (++i)*(++i));

이를 보면 알겠지만 증가 연산자가 한 문장 안에서 동시에 쓰였다.

원하는 내용은 i 가 1증가하는 것이지만 실제로는 2가 증가하게 된 것이다.

실제로 결과값은 3*4==12 가 나온다.

C) 매크로 함수를 사용하는 이유

- 매크로 함수를 사용하는 이유는 간단한 함수를 사용할 때 굳이 실제의 함수를 만들지 않고, 매크로 함수로 만들어 사용함으로써 보다 간단한 프로그래밍을 할 수 있기 때문이다. 물론 복잡한 기능을 가지는 함수들은 매크로 함수로 만들 수 없겠지만, 간단한 연산을 하는 정도의 함수는 매크로 함수로 작성하는 것이 좋다. 가령 간단한 연산을 하는 함수가 굉장히 빈번하게 프로그램 곳곳에서 호출된다고 생각해 보자. 함수가 호출될 때 생기는 여러 가지 작업들(예를 들어 자동변수를 만들었다 없애는 등의 작업) 때문에 상당히 많은 시간을 소비하게 된다. 특히 반복문 안에서 그 함수를 호출하게 되면, 그 시간은 더욱 길어진다. 하지만 이런 함수를 매크로 함수로 바꾸게 되면, 실제적으로 함수를 호출하는 일이 없어서 빠른 시간에 작업을 처리할 수 있게 된다.

물론 단점도 있는데, 함수는 하나의 루틴을 계속 불러서 사용하지만 매크로 함수는 모두 치환이 되기 때문에 실행 파일의 크기가 커질 수도 있다.

D) 매크로 함수의 용도

① 중복되는 수식을 매크로 함수로 간결하게 기술

- 프로그래밍을 하다보면 특정 수식이 계속해서 쓰이는 경우가 있는데, 이것을 따로 함수로 만들어 쓰자니 실행속도가 문제될 것 같고, 그대로 수식으로 쓰자니 프로그램이 너무 복잡해 질 것 같은 상황에서, 이러한 수식을 매크로 함수로 치환하면 소스가 판독하기 쉽고 간결해진다.

② 표준 라이브러리 함수의 특정 실매개변수를 특정 값으로 지정한 경우

- 프로그램을 작성하다 보면 표준 라이브러리 함수의 특정한 매개변수를 항상 특정한 값으로 지정하여 쓰는 경우가 많다. 예를 들어 HGC에서는 floodfill() 함수의 3번째 매개변수가 항상 1일 수 밖에 없다. 이처럼 floodfill(x, y, 1) 과 같이 매번 1이라는 값을 지정해 주기가 번거러울 때 매크로 함수를 쓰면 된다.

     #define  paint(x, y)  floodfill(x, y, 1)>

③ 매개변수의 데이터형을 제한하고 싶지 않을 때

- 실제함수는 실매개변수의 데이터형이 제한되어 있지만, 매크로 함수는 데이터형이 제한되어 있지 않으므로 모든 데이터형을 매개변수로 사용할 수 있다.

8-4. typedef 문

typedef문은 새로운 형을 정의하는데 쓰인다. 예를 들어 unsigned char 형은 형 이름이 길어서 불편하다고 느껴질 수도 있다. 이럴 때 typedef문을 사용해서 byte형이라고 간단히 정의해 버리면 편리하다. 아래에 typedef문의 선언형식을 설명하였다.

typedef문을 마구 남용하면 오히려 데이터형의 혼동을 가져오므로, 되도록 대단히 복잡한 데이터형(열거형, 구조체형, 공용체형 같은 경우)에만 사용하는 것이 좋다.

8-5. 열거형 데이터

이 글 처음부분의 데이터형을 보면 설명없이 넘어간 열거형이 있고, 상수에 보면 열거상수가 있다. 열거형(enumerated type)은 그러한 열거상수(==열거멤버)들의 모임이라고 볼 수 있다. 열거형을 enum형이라고 부르기도 한다.

열거형 상수의 선언방법은 다음과 같다.

enum {멤버1, 멤버2, . . . } 열거형 변수1, 열거형 변수2, . . .

위에서 멤버는 문맥에 따라 열거멤버라고 불리기도 하고, 열거상수로 불리기도 한다. 열거멤버를 열거상수라고도 부르는 이유는 열거멤버가 프로그램 내에서는 매크로 상수와 거의 동등하게 사용되기 때문이다. 즉, 열거멤버는 정수상수의 기호적 표현이라 보면 된다.

열거형 상수는 사용자가 임의로 값을 지정할 수도 있고, 열거형 상수의 첫 번째 값을 임의로 지정할 수도 있다.

void main()
{
   enum {zero,one,two,three,four,       \\
         five,six,seven,eight,nine,ten} number;
 
   number=one+six;   /* 열거형 상수를 이용해 덧셈을 함 */
   printf("One+Six=%d\n",number);
}

위의 예에서도 볼 수 있듯이 열거형 상수는 일반 수식에서 정수형 상수처럼 쓰이며, int 형으로 자동변환된다. (enum 형이 부호없는 형이면 unsigned형으로 변환되기도 한다.)

그런데, 위 예제와 같은 열거형 상수 선언은 한 가지 문제점이 있다. 열거형 상수를 인식하는데 선언된 그 함수에만 국한된다는 것이다. 그래서, 다른 함수에서는 같은 열거형 상수를 쓸 수 없다는 결과가 나온다. (선언은 중복될 수 있어도, 정의는 중복될 수 없으므로)

이 문제는 열거형 상수를 다른 방법으로 선언함으로써 해결할 수 있다.

① 열거택에 의한 선언

enum 열거택 {열거형 상수1, 열거형 상수2, . . . };

enum 열거택 열거형 변수1, 열거형 변수2, . . . ;

이 선언방법은 위에서 열거형 변수의 선언형태를 선언하고, 아래에서 두 번째 라인의 방법으로 실제적인 변수를 정의하는 방법이다.

#include <stdlib.h>
 
enum su {zero,one,two,three,four,five,six,seven,eight,nine,ten};
 
void test(void);
 
void main()
{
   enum su a;   /* 열거형 택을 이용해서 열거형 변수 a를 선언 */
 
   a=one+six;    /* 열거형 상수를 이용해 덧셈을 함 */
   printf("One+Six=%d\n",a);
   test();
}
 
void test(void)
{
   enum su b;   /* 열거형 택을 이용해서 열거형 변수 b를 선언 */
   b=two+five;
   printf("One+Five=%d\n",b);
}

② typedef문을 이용한 선언 이 방법은 tytpedef문을 이용해서 열거형을 선언하는 새로운 데이터형을 만들어 사용하는 것이다.

typedef enum {zero,one,two,three,four,five,         \\
              six,seven,eight,nine,ten} number;
/* enum형을 선언하는 새로운 데이터형 number를 만듬 */
 
void test(void);
 
void main()
{
   number a;
   /* 새로운 데이터형 number를 사용해서 열거형 변수 a를 선언 */
 
   a=one+six;
   printf("One+Six=%d\n",a);
   test();
}
 
void test(void)
{
   number b;
   /* 새로운 데이터형 number를 사용해서 열거형 변수 b를 선언 */
 
   b=two+five;
   printf("One+Five=%d\n",b);
}