두근두근 울렁울렁 가슴 뛰지만 무섭고도 두려워서 겁이 나지만 요즘 재미있는 코드 조각들이 올라네요. 저도 하나 써보려고요 :)

발단은... container_of() 매크로의 두 가지 구현인
#define container_of(ptr, type, member) ((type *)((char *)(1 ? (ptr) : &((type *)0)->member) - offsetof(type, member)))
과
#define container_of(ptr, type, member) ((type *)((char *)(ptr) - offsetof(type, member)))
을 비교하면서 삼항연산자에 쓰인 1 에 대해 설명을 읽어도 무슨 내용인지 이해할 수 없었던 일 때문이었습니다. (아직 이해하지 못합니다.) 이걸 이해해보려고 이것 저것 찾아보다 또 다른 재미난 사용법을 알게되었습니다. 바로 +0 의 사용법입니다 :) 그리고, 알아두면 언젠가는 쓸모있을지도 모른다는 생각이 들더라고요.

언뜻 생각하면 0 을 더한다는 것은 의미가 없어보입니다. 그러나, C 언어의 프로모션 규칙을 생각하면 나름 쓸모있는 사용법이 생깁니다. 0 이 int 기 때문이죠. 문자형 변수에 0 을 더하면 int 형으로 승급합니다. 물론, 이것 자체로도 큰 의미는 없습니다. 그런데, gcc 와 clang 은 typeof 와 __auto_type 이란 확장기능이 있습니다. (__auto_type 은 C++11 의 auto 와 비슷합니다.) 또, gcc 와 clang 은 _Generic 이란 C11 표준을 지원합니다. (비주얼 스튜디오 C 에서는 아직 지원하지 않습니다.) 이런것들을 결합하면 +0 을 재미나게 사용할 수 있습니다. 우선, _Generic 의 예를 하나 보죠.

#define MACRO1(X) _Generic ((X), int: "int", double: "double")

int i = 99;
printf ("%s\n", MACRO1 (i));

은 "int" 라는 문자열을 출력합니다. 만일 i 가 double 형이라면 "double" 이란 문자열을 출력할 것입니다. _Generic 은 이처럼 변수의 타입에 따라 다른 동작을 하도록 합니다. 이 간단한 예에서는 단순히 다른 문자열을 지정했지만, 만일 함수를 선택하게 한다면 어떻게 될까요? C++ 의 함수 오버로딩과 비슷한 일을 할 수 있습니다.

#define MACRO2(X) _Generic ((X), int: printf ("int %d\n", (X)), double: printf ("double %lf\n", (X)))

int i = 99;
MACRO2 (i);

그런데, _Generic 은 인자로 변수를 받습니다. 만일 변수가 아니라 타입을 받도록 하려면 어떻게 할까요? 변수를 만들어줘야 합니다. Gcc 와 clang 은 statement expression 이란 확장기능이 있습니다. 괄호로 둘러쌓인 복합문의 마지막 표현식의 값이 그 문장식이 돌려주는 값이 됩니다. 예를 들어, ({ int a = 1; a; }) 라는 문장식은 1 이란 값을 돌려줍니다. (비주얼 스튜디오 C 는 지원하지 않습니다.) MACRO1() 매크로를 다음과 같이 바꾸면 타입을 받도록 할 수 있습니다.

#define MACRO3(T) _Generic (({ T X = 0; X; }), int: printf ("int\n"), double: printf ("double\n"))

MACRO3 (double);

만일, 변수도 받을 수 있고 또는 타입도 받을 수 있도록 하려면 어떻게 할까요? 이렇게 바꿉니다.

#define MACRO4(X) _Generic (({ typeof(X) A = 0; A; }), int: printf ("int\n"), double: printf ("double\n"))

int i = 99;
MACRO4 (i);
MACRO4 (double);

이제 변수도 받을 수 있고 또는 타입도 받을 수 있지만, 변수인 경우 그 값을 출력하려면 어떻게 할까요? 만일 타입인 경우는 0 을 출력하도록 합시다.

#define MACRO5(X) ({ typeof(X) A = (X)+0; _Generic (A, int: printf ("int %d\n", A), double: printf ("double %lf\n", A)); })

double d = 99.9;
MACRO5 (int);
MACRO5 (d);

같은 일을 하는 아래 코드가 조금 더 보기 좋습니다:)

#define MACRO6(X) ({ __auto_type A = (X)+0; _Generic (A, int: printf ("int %d\n", A), double: printf ("double %lf\n", A)); })

int i = 99;
MACRO6 (i);
MACRO6 (double);

이들 매크로에서 X 가 타입인 경우 (X)+0 은 0 이란 값을 X 란 타입으로 형변환하는 기능을 합니다. X 가 변수인 경우 그 변수에 0 을 더하는 기능을 하고요. 이제 아무런 문제가 없을까요? 다음 예를 보죠.

#define MACRO7(X) ({ __auto_type A = (X)+0; _Generic (A, char: printf ("char %hhi\n", A), int: printf ("int %d\n", A), double: printf ("double %lf\n", A)); })

char c = 0;
MACRO7 (c);
MACRO7 (char);

MACRO7 (char) 는 정상적으로 동작합니다. 그러나, MACRO7 (c) 는 int 로 처리됩니다!! 문자형 변수에 0 을 더하면 int 로 승급하기 때문이죠TT 다음과 같이 수정합니다.

#define MACRO8(X) ({ __auto_type A = (typeof (X))((X)+0); _Generic (A, char: printf ("char %hhi\n", A), int: printf ("int %d\n", A), double: printf ("double %lf\n", A)); })

char c = 0;
MACRO8 (c);
MACRO8 (char);

이제 아무런 문제가 없을까요? 위에서 "타입인 경우는 0 을 출력하도록 합시다"라고 했지만, 아무래도 타입과 값을 구분하는 것이 더 좋을 것 같습니다. 이렇게 수정합니다.

#define MACRO9(X) __builtin_choose_expr (__builtin_constant_p ((X)+0), _Generic (({ __auto_type A = (typeof (X))((X)+0); A; }), char: printf ("char type\n"), int: printf ("int type\n"), double: printf ("double type\n")), ({ __auto_type A = (typeof (X))((X)+0); _Generic (A, char: printf ("char type value %hhi\n", A), int: printf ("int type value %d\n", A), double: printf ("double type value %lf\n", A)); }))

char c = 0;
MACRO9 (c);
MACRO9 (char);

위에서 (X)+0 의 기능은, X 가 타입인 경우 형변환 연산이고 X 가 변수인 경우는 덧셈이라고 말했습니다. 여기에, 새로운 사용법이 있습니다. Gcc 와 clang 의 __builtin_constant_p() 함수는 인자로 받은 것이 상수인지 아닌지 평가합니다. 여기서 상수라고 하는 것은 변수가 아니라는 뜻입니다. (한정자 const 를 사용한 변수도 변수입니다.) 타입은 변수가 아닙니다. 물론, 평가할 수 있는 상수도 아닙니다. (상수인 0 을 형변환해서 평가하는 이유입니다.) __builtin_choose_expr() 함수는 삼항연산자와 비슷한 연산자입니다. 이 연산의 조건식으로 __builtin_constant_p() 를 사용하면 코드 최적화 전에 평가합니다. 따라서, (X)+0 으로 X 가 변수인지 아닌지(즉, 타입인지) 검사할 수 있습니다. 자, 이제 아무런 문제가 없을까요?

int i = 99;
MACRO9 (i);
MACRO9 (99);

진짜 상수인 경우와 타입을 구분하지 못합니다!! 이렇게 수정합니다.

#define MACRO10(X) __builtin_choose_expr (__builtin_constant_p ((X)+0), (((X)+1 == (typeof (X))+1) ? _Generic (({ __auto_type A = (typeof (X))((X)+0); A; }), char: printf ("char type\n"), int: printf ("int type\n"), double: printf ("double type\n")) : ({ __auto_type A = (typeof (X))((X)+0); _Generic (A, char: printf ("char type value %hhi\n", A), int: printf ("int type value %d\n", A), double: printf ("double type value %lf\n", A)); })), ({ __auto_type A = (typeof (X))((X)+0); _Generic (A, char: printf ("char type value %hhi\n", A), int: printf ("int type value %d\n", A), double: printf ("double type value %lf\n", A)); }))

int i = 99;
MACRO10 (i);
MACRO10 (99);

상당히 길고 복잡해졌습니다. 상수와 타입을 구분하기 위해 (X)+1 == (typeof (X))+1 을 조건으로 삼항연산자를 하나 썼습니다. 변수와 타입을 구분하기위한 조건인 (X)+0 과 비슷하죠. 그런데, 상수와 타입을 구분하는 조건식은 상수식이 아닙니다. (__builtin_choose_expr() 을 사용할 수 없습니다.) 지금까지 과정을 따라왔다면 이해하기 어려운 코드는 아닐 것 입니다. (줄바꿈을 쓰면 조금 더 보기 좋을텐데 오유가 pre 태그나 code 태그를 잘 지원하지 못하는 것 같습니다TT) 그리고, 코드를 긁어서 시험해보기 쉽도록 한줄로 썼습니다 :)

__builtin_choose_expr() 는 삼항연산자와 달리 조건에 따라 한 쪽 코드만 전개합니다. 그런데, 지금 구현된 __builtin_choose_expr() 이 전개하지 않는 코드에대해서도 구문검사는 하기때문에 조금 더 복잡해졌습니다. 미래에 구현될 __builtin_choose_expr() 는 전개하지 않는 코드에 대해서는 구문검사를 하지 않을 예정이라고 합니다. 그렇게된다면 불필요한 부분을 줄일 수 있겠죠 :)

이렇게 변수와 변수가 아닌 것을 구분하고, 또 상수와 타입을 구분하는 방법을 알아봤습니다.

__builtin_choose_expr (__builtin_constant_p ((X)+0), (((X)+1 == (typeof (X))+1) ? 타입인경우 : 상수인경우), 변수인경우)

---

덧붙임1: __builtin_choose_expr (__builtin_constant_p ((X)+0), (((X)+1 == (typeof (X))+1) ? 타입인경우 : 상수인경우), ({ __auto_type A = ((typeof (X))((X)+0)); ((((void*)(A + 1)) != (((void*)A) + 1)) ? 일반변수인경우 : 포인터인경우); }))
이 가능성이 있어보이는데... 나중에 리디퍼런싱 할 때 포인터가 아닌 놈도 * 를 적용해보는 구문검사를 해서 사용할 수 없네요TT

덧붙임2: 예제의 매크로는 간단히 보여주기위해 printf() 함수를 직접 호출합니다. 그런데, 어떤 때는 정수를 또 어떤 때는 실수를 인자로 받습니다. 정수를 인자로 받았을 때는 printf() 의 "%lf" 와 실수를 인자로 받았을 때는 "%d" 와 형식이 맞지 않습니다. 컴파일러의 -Wformat 옵션이 켜진 경우 경고가 발생합니다. 이 경고가 보기 싫다면, printf() 함수를 직접 호출하지 말고 print_integer() 나 printf_double() 이라는 함수로 printf() 함수를 감싸거나 명시적 형변환을 한번 더 해주세요.