UNICODE、_UNICODE、__TEXT、__T、_T、_TEXT、TEXT宏

kenson

/ I# N% J0 K: \% c- I" I
& Z8 ^% q& b2 n" }! w, v8 I
5 r# Q% }' Q) _0 y最近在看一些关于VC++和MFC的书时，书上对字符串的处理一般都会使用TEXT("a string")的形式或者_T("a string")的形式，自己写程序时MFC自动生成的代码中也有类似的宏。作为菜鸟，不加思考地照搬书上的TEXT()或者_T()不是我的风格，喜欢追根究底的性格促使我决定弄懂这些宏。但如果我按照以往写文章的习惯，跟着我思考的顺序来写这篇随笔的话，那是倒叙，会很不好写，所以我就按弄懂之后的正常顺序来写吧，但这也让这篇随笔看起来有点说教，各位看客且请忍受一下，谢谢。

7 T& j/ k% Y* E% _! E$ h: PC语言发明时尚没有UNICODE这一说，那时候米国人只有ASCII，但随着计算机的进化，程序中需要出现其它国家语言的字符，如中文，这远不是ASCII所能表示的，所以就出现了UNICODE（想深入了解UNICODE的童鞋，请猛击这里），于是C语言也新加了一个类型：wchar_t，用于表示UNICODE字符，其定义为：#define unsigned short wchar_t，说白了其实就是用16位双字节表示一个字符（ASCII用单字节表示一个字符）。

这样编写程序就出现了一个问题，我先定义了一个变量：char *str = "china";这当然没问题，但如果后来要把该字符串换成中文的，那就得换成wchar_t *str = L"中国";（顺便说一下，字符串前的L是告诉编译器，后面紧跟的字符串按UNICODE宽字符处理，即每个字符占两个字节）。如果字符串只有一个，改一下没问题，但很难想象一个程序中只出现一个字符串，所以，这样修改起来的工作量是很大的。

M$永远不会缺乏牛人，所以他们自然为VC++想好了解决办法，那就是__TEXT()，__T()等一系列宏，先来看看WinNT.h头文件，这个文件有几千行，但我们只需要抽取关键的几行出来：

8 u9 w- w  w& h. C) k#ifdef  UNICODE                     // r_winnt
#define __TEXT(quote) L##quote      // r_winnt
#else   /* UNICODE */               // r_winnt
#define __TEXT(quote) quote         // r_winnt
#endif /* UNICODE */                // r_winnt
0 h2 @2 d& s7 X+ C  n#define TEXT(quote) __TEXT(quote)   // r_winnt
+ U5 C4 A% S" E( s这几行代码应该很简单：如果定义了UNICODE宏，那么就将__TEXT(quote)宏定义为L##quote，如果没定义UNICODE宏，则__TEXT(quote)宏就是普通的quote，最后，再将TEXT(quote)宏定义为__TEXT(quote)宏。（如果有朋友不懂其中##符号的意思的话，这里解释一下，##起连接作用，例如__TEXT("china")在经过宏替换后就会被解释为L"china"）
$ m) y4 _9 l, }- Q6 j; ?' Q
这种解决方法很巧妙，编程人员可以根据需要自由定义UNICODE宏来决定是使用ASCII字符串还是UNCODE字符串，而程序中的字符、字符串只需加个宏处理即可。与此类似的还有__T()，_TEXT()等宏，这些宏在tchar.h头文件里定义，这个文件同样有几千行，仍然只需要抽出关键的几行：

4 P8 N: B5 s- ]5 p) N' G复制代码
# s8 i3 p! U2 \$ ~#ifdef  _UNICODE
#define __T(x)      L ## x
, r7 k7 v0 G+ I' K* P7 }#else   /* ndef _UNICODE */
4 Y2 E  ?8 L$ L3 ^2 q3 J#define __T(x)      x
#endif  /* _UNICODE */
3 f. M- C4 n5 W  t6 l#define _T(x)       __T(x)
4 \' i+ g8 i4 u0 J2 G% J' Z, P#define _TEXT(x)    __T(x)
复制代码
" \1 [4 n2 Q+ _: Q其原理同上，但这里是根据_UNICODE宏（注意前面的下划线）来决定是使用ASCII字符还是UNICODE字符的。同样最后又附加了_T()和_TEXT()宏的定义。

2 t' I; \, g' l( s' e8 U; ]7 d( e到此，疑问又来了，为什么要定义_UNICODE和UNICODE两个宏？M$的牛人吃多了嫌撑？要是一个宏定义了，另一个宏没定义引起冲突怎么办？于是再来查找一番，在atldef.h和afxv_w32.h两个头文件中，我找到了一模一样的内容，如下：
7 K: b$ }; ]: B3 ^7 J) m
复制代码
. d2 n( U) z+ i7 F1 w& m8 j#ifdef _UNICODE
#ifndef UNICODE
* Q- T$ |' J5 X- ?- m" [#define UNICODE         // UNICODE is used by Windows headers
$ ?0 d  T; f8 A# S#endif
, Z- O% E# Q" p$ Q; R#endif

" k7 {  \6 f9 {& k#ifdef UNICODE
$ o$ x7 _& o/ A0 @8 ?# O  x  ^#ifndef _UNICODE
: N. g/ s$ x, f0 M. j: O#define _UNICODE        // _UNICODE is used by C-runtime/MFC headers
#endif
#endif
2 f) G( ]0 A" b5 S5 M% v8 d复制代码
这段代码有点绕，但目的很清晰，就是要保证UNICODE和_UNICODE这两个宏要么都定义了，要么都未定义，不能只定义一个。所以，在上面的分析中，不论是利用UNICODE宏来定义的__TEXT()和TEXT()，还是利用_UNICODE宏来定义的__T()、_T()和_TEXT()，都是可以正常使用的，不会出现一部分是ASCII字符串，另一部分是UNICODE字符串的低等错误。因此，__TEXT、__T、_T、_TEXT、TEXT这几个宏的具体作用其实是一样的，没有区别，至于M$为什么对相同的功能要搞这么多奇形怪状的符号来表示，那我就不得而知了。

同时，上面的注释还解释了，UNICODE宏用于Windows头文件，而_UNICODE宏用于C运行时和MFC的头文件，当然我这个菜鸟还不太懂具体区别，只能大概猜到，在Windows的头文件中，需要根据是否使用UNICODE来定义不同版本宏的地方就使用UNICODE宏，而在MFC和标准C中，需要根据是否使用UNICODE来定义不同版本宏的地方就使用_UNICODE宏。
, ~; m. X# ?, o  i/ A" T9 U
1 X& x5 X( V# j/ B另外，小弟真的很菜，尚不知为何关于UNICODE和_UNICODE这两个宏的纠缠在atldef.h和afxv_w32.h两个文件中都出现了，而且还一模一样，园子里高手众多，如果哪位知道这其中的奥秘，还望能给小弟指点一二，先行谢过。

kenson

C语言之＃define用法（终极盘点篇）2008-08-27 20:56一.
#define是C语言中提供的宏定义命令，其主要目的是为程序员在编程时提供一定的方便，并能在一定程度上提高程序的运行效率，但学生在学习时往往不能 理解该命令的本质，总是在此处产生一些困惑，在编程时误用该命令，使得程序的运行与预期的目的不一致，或者在读别人写的程序时，把运行结果理解错误，这对 C语言的学习很不利。
1　#define命令剖析
/ [+ S  t. b: L4 A1.1   #define的概念
" Z9 i: M8 C& s# S1 `) i#define命令是C语言中的一个宏定义命令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。
% e3 e0 ?- W+ A该命令有两种格式：一种是简单的宏定义，另一种是带参数的宏定义。
$ A+ \* a& {3 T" Q( r(1)   简单的宏定义：
#define   <宏名>　　<字符串>
$ d& s9 G) d! a4 U- v; i   例：   #define PI 3.1415926
(2) 带参数的宏定义
" Y% ^) n" l& r" J3 B# b) b  j   #define   <宏名> (<参数表>)   <宏体>
   例： #define   A(x) x
1 J. ^% |4 M5 I一个标识符被宏定义后，该标识符便是一个宏名。这时，在程序中出现的是宏名，在该程序被编译前，先将宏名用被定义的字符串替换，这称为宏替换，替换后才进行编译，宏替换是简单的替换。
1.2 宏替换发生的时机
为了能够真正理解#define的作用，让我们来了解一下对C语言源程序的处理过程。当我们在一个集成的开发环境如Turbo C中将编写好的源程序进行编译时，实际经过了预处理、编译、汇编和连接几个过程，见图1。
源程序
4 ^2 n' y6 T4 p0 v
6 ]* y' z  c7 V- z预处理器

2 T9 r# g8 n" A* c8 R修改后的源程序

编译器
) \2 ^/ g; m1 V& I9 i3 R! [7 T
汇编程序
+ K' M0 k( L& W% A( q3 p7 e7 f% e
) c4 O! l8 p5 ~' Z汇编器
' o7 f! V% E9 M
4 w9 q! D3 N. z) C( f( c2 q: ?1 v可重定位的目标程序
! g  i& Y  A3 {) `; \# w
连接器
2 Z* `& Q! |- E
# m8 x7 B. L3 l可执行的目标程序
( O/ _" [8 U9 f$ ]
图1　C语言的编译过程
( S' ~5 `1 v/ j$ o
其中预处理器产生编译器的输出，它实现以下的功能：
' x) g5 V6 F7 A( |1 r/ c% j) j（1）    文件包含
; Z1 p; D8 {# H/ v3 X8 }8 V9 ~% u可以把源程序中的#include 扩展为文件正文，即把包含的.h文件找到并展开到#include 所在处。
（2）    条件编译
1 Q3 O8 @, [% u/ a预处理器根据#if和#ifdef等编译命令及其后的条件，将源程序中的某部分包含进来或排除在外，通常把排除在外的语句转换成空行。
9 |) y# T2 J- w- t（3）    宏展开
& X% C  {' P; H预处理器将源程序文件中出现的对宏的引用展开成相应的宏 定义，即本文所说的#define的功能，由预处理器来完成。
4 M% {: {; a4 D8 _经过预处理器处理的源程序与之前的源程序有所有不同，在这个阶段所进行的工作只是纯粹的替换与展开，没有任何计算功能，所以在学习#define命令时只要能真正理解这一点，这样才不会对此命令引起误解并误用。
9 `( q: k& T( r) J( o5 i. q1 H6 c
2　#define使用中的常见问题解析
5 S6 \) M. V1 m) G2.1 简单宏定义使用中出现的问题
在简单宏定义的使用中，当替换文本所表示的字符串为一个表达式时，容易引起误解和误用。如下例：
; U) B" x* G, p. K例1   #define   N   2+2
: [0 i+ B; u! Y/ b$ kvoid main()
{
   int   a=N*N;
   printf(“%d”,a);
+ |/ j8 O2 M* H/ u0 ^* K}
2 x. R( z/ ]) _8 M5 H(1) 出现问题：在此程序中存在着宏定义命令，宏N代表的字符串是2+2，在程序中有对宏N的使用，一般同学在读该程序时，容易产生的问题是先求解N为2＋2＝4，然后在程序中计算a时使用乘法，即N*N=4*4=16,其实该题的结果为8，为什么结果有这么大的偏差?
) ?. }. J& V, I: s! u' L4 ?(2)问题解析：如1节所述，宏展开是在预处理阶段完成的，这个阶段把替换文本只是看作一个字符串，并不会有任何的计算发生，在展开时是在宏N出现的地方 只是简单地使用串2＋2来代替N，并不会增添任何的符号，所以对该程序展开后的结果是a=2+2*2+2，计算后=8，这就是宏替换的实质，如何写程序才 能完成结果为16的运算呢？
(3)解决办法：将宏定义写成如下形式
#define   N   (2+2)
这样就可替换成(2+2)*(2+2)=16
6 n. J# y$ g0 a9 t2.2 带参数的宏定义出现的问题
# }3 d  c( E# P2 N# A+ p* A在带参数的宏定义的使用中，极易引起误解。例如我们需要做个宏替换能求任何数的平方，这就需要使用参数，以便在程序中用实际参数来替换宏定义中的参数。一般学生容易写成如下形式：
; Y0 s, n) V! Z" a#define   area(x)   x*x
8 {& }3 ]9 A! p! y这在使用中是很容易出现问题的，看如下的程序
void main()
{
6 X8 s! I5 g6 Y0 ^int   y=area(2+2);
printf(“%d”,y);
    }
按理说给的参数是2+2，所得的结果应该为4*4=16，但是错了，因为该程序的实际结果为8，仍然是没能遵循纯粹的简单替换的规则，又是先计算再替换 了，在这道程序里，2+2即为area宏中的参数，应该由它来替换宏定义中的x，即替换成2+2*2+2=8了。那如果遵循(1)中的解决办法，把2+2 括起来，即把宏体中的x括起来，是否可以呢？#define   area(x) (x)*(x)，对于area(2+2)，替换为(2+2)*(2+2)=16，可以解决，但是对于area(2+2)/area(2+2)又会怎么样 呢，有的学生一看到这道题马上给出结果，因为分子分母一样，又错了，还是忘了遵循先替换再计算的规则了，这道题替换后会变为 (2+2)*(2+2)/(2+2)*(2+2)即4*4/4*4按照乘除运算规则，结果为16/4*4=4*4=16，那应该怎么呢？解决方法是在整个 宏体上再加一个括号，即#define   area(x) ((x)*(x))，不要觉得这没必要，没有它，是不行的。
要想能够真正使用好宏定义，那么在读别人的程序时，一定要记住先将程序中对宏的使用全部替换成它所代表的字符串，不要自作主张地添加任何其他符号，完全展 开后再进行相应的计算，就不会写错运行结果。如果是自己编程使用宏替换，则在使用简单宏定义时，当字符串中不只一个符号时，加上括号表现出优先级，如果是 带参数的宏定义，则要给宏体中的每个参数加上括号，并在整个宏体上再加一个括号。看到这里，不禁要问，用宏定义这么麻烦，这么容易出错，可不可以摒弃它， 那让我们来看一下在C语言中用宏定义的好处吧。

3   宏定义的优点
) h. H+ J( q8 f# t* _(1)   方便程序的修改
使用简单宏定义可用宏代替一个在程序中经常使用的常量，这样在将该常量改变时，不用对整个程序进行修改，只修改宏定义的字符串即可，而且当常量比较长时， 我们可以用较短的有意义的标识符来写程序，这样更方便一些。我们所说的常量改变不是在程序运行期间改变，而是在编程期间的修改，举一个大家比较熟悉的例 子，圆周率π是在数学上常用的一个值，有时我们会用3.14来表示，有时也会用3.1415926等，这要看计算所需要的精度，如果我们编制的一个程序中 要多次使用它，那么需要确定一个数值，在本次运行中不改变，但也许后来发现程序所表现的精度有变化，需要改变它的值， 这就需要修改程序中所有的相关数值，这会给我们带来一定的不便，但如果使用宏定义，使用一个标识符来代替，则在修改时只修改宏定义即可，还可以减少输入 3.1415926这样长的数值多次的情况，我们可以如此定义 #define   pi   3.1415926，既减少了输入又便于修改，何乐而不为呢？
(2) 提高程序的运行效率
% ?9 R) v  T' i/ @使用带参数的宏定义可完成函数调用的功能，又能减少系统开 销，提高运行效率。正如C语言中所讲，函数的使用可以使程序更加模块化，便于组织，而且可重复利用，但在发生函数调用时，需要保留调用函数的现场，以便子 函数执行结束后能返回继续执行，同样在子函数执行完后要恢复调用函数的现场，这都需要一定的时间，如果子函数执行的操作比较多，这种转换时间开销可以忽 略，但如果子函数完成的功能比较少，甚至于只完成一点操作，如一个乘法语句的操作，则这部分转换开销就相对较大了，但使用带参数的宏定义就不会出现这个问 题，因为它是在预处理阶段即进行了宏展开，在执行时不需要转换，即在当地执行。宏定义可完成简单的操作，但复杂的操作还是要由函数调用来完成，而且宏定义 所占用的目标代码空间相对较大。所以在使用时要依据具体情况来决定是否使用宏定义。
" d! A& c# }3 R" p6 F3 x
' J6 A  `. D/ z  y, X6 U: e4 结语
本文对C语言中宏定义#define在使用时容易出现的问题进行了解析，并从C源程序处理过程的角度对#define的处理进行了分析，也对它的优点进行 了阐述。只要能够理解宏展开的规则，掌握使用宏定义时，是在预处理阶段对源程序进行替换，只是用对应的字符串替换程序中出现的宏名，这样就可在正确使用的 基础上充分享受使用宏定义带来的方便和效率了
/ Q$ G1 u- y4 C8 n( G7 m4 \3 m# S  J
* `1 n1 U# `: f& L- Q1 o, C% u二.
" Q$ h3 z( @3 Z/ i最近看com相关的资料，看到CCmdTarget实现com接口的时候，去读了一些宏的定义，在afxdisp.h头文件中
7 r0 ]6 F& P8 B! J$ D- `, x
3 B5 _  L7 d2 g4 }) q" ?* h#define BEGIN_INTERFACE_PART(localClass, baseClass) \
class X##localClass : public baseClass \
* X3 W) P: V$ O2 D( d+ k. w* i
本来这个宏定义很容易理解的，但是这里多出个X##，我真没见过这种用法，不晓得它是什么用意。
# b* _( N& I  p( Y- x/ w后来问了几个朋友也都不知道。
8 \& b$ j, F/ P
% F% `" G8 ~/ S( x$ Y- `你知道么？
0 H3 I1 a. `, R- A/ i! D. i; Z+ o+ C
也许你也不知道～呵呵，最后我还是找到了相关的资料，解读了这个define，还顺便认识了另外两个不常用的define

* g! B1 d! f4 ~. K#define Conn(x,y) x##y
; d' a/ x7 M( R#define ToChar(x) #@x
) i1 K. Y+ W" r6 u( J5 T#define ToString(x) #x

x##y表示什么？表示x连接y，举例说：
' x: h/ t& s. ?3 _int n = Conn(123,456);   结果就是n=123456;
) K8 p4 a5 }- {8 o9 T/ `( xchar* str = Conn("asdf", "adf")结果就是 str = "asdfadf";
- g6 `/ }- y5 z: S怎么样，很神奇吧

8 S* [# C$ R* ~+ V1 `再来看#@x，其实就是给x加上单引号，结果返回是一个const char。举例说：
char a = ToChar(1);结果就是a='1';
做个越界试验char a = ToChar(123);结果是a='3';
但是如果你的参数超过四个字符，编译器就给给你报错了！error C2015: too many characters in constant   ：P
" f. I: }; d: n$ k" G) s6 G
最后看看#x,估计你也明白了，他是给x加双引号
char* str = ToString(123132);就成了str="123132";
9 J1 a& Q* i9 ^5 G4 W+ x! o
1 _: z7 ^' q; }8 Z最后留几个小试验给大家去测测：
#define Dec(x,y) (x-y)
int n = Dec( A(123,1), 1230);
$ p. I( i' @* Y+ k/ p( Sn = Conn(123, Conn(123,332) );
( K% R4 D' ^- Kchar* str = A("12", ToString( Dec(3,1));
结果会如何呢？ 嘿嘿嘿嘿~
9 |' P7 r8 y1 G- H
三.
- }- z! }! G$ |9 o% R8 m#define xxx() {}
标准C支持的
#define xxx() ({})
GCC新增的功能，主要为了防止宏展开出现问题，默认展开时是要加上一个;的，容易出问题。

# X7 W# v* y9 `& X+ x' }
CODE:#define A(a,b,c) ({a=1;b+=1;c=3;a+b+c;})
#include <stdio.h>
int main()
9 \/ ~/ @1 k* b% m# Q- ?{
4 q) X; {) E: D/ J' P: ~8 }2 A$ {! t       int a;
+ N4 w4 w" x, e       int b=1;
' a! Y0 v" q0 U2 l) w- @9 [( J       int c;
       int d;
       d=A(a,b,c);
7 E5 s1 h9 m+ X       printf("%d,%d,%d,%d\n",a,b,c,d);
       return 0;
) d- v+ F: M7 a7 L}
: i( U3 i% B! l4 c8 ?) v5 A表示该宏函数还有返回值，最后一个式子的返回值作为宏函数的返回值。
" W6 n6 o+ A* l0 p9 u% |运行结果：
& K1 m$ }  [+ \6 Q) l1,2,3,6

kenson

http://www.amobbs.com/thread-750189-1-1.html

kenson

( B$ U. |, r* E/ ~, n- v! U
1 v) z: @9 j& ]2 n" y

指针数组和指向数组的指针
       int * pi[3];      //pi是指向int类型的指针数组

       int a[][3] ={{1,2,3}, {1,2,3}, {1,2,3}};      //两维数组即数组的数组，a[0]是一个一维的3个int型元素的数组
       int (*pa)[3] = a;      //pa是一个指向3个int元素的数组的指针

       const
1 c& b8 q; A3 o2 h, H       const char* p1;      //指针本身不是常量，可以p1++，但指向的东西不能修改，*p1='a'不行
# `) x+ i- }0 K: V* s+ ^       char* const p2;      //指针本身是常量，p2++不行，但可以修改指向的内容，*p2='b'可以
& H7 X% H; }0 }2 p       const char* const p3;      //指向常量的指针常量

       函数指针
       int (*fp)(const char*, …) = fprintf;      //调用可以fp("hello") 或者 (*fp)("hello")

       extern void insert(void);
       extern void update(void);
       extern void delete(void);
       void (*farray[])(void)={insert, update, delete};      //farray是一个函数指针数组，调用farray[0]()

( I" U+ l% M( W$ e

kenson

C/C++ 宏详解

众多C++书籍都忠告我们C语言宏是万恶之首，但事情总不如我们想象的那么坏，就如同goto一样。宏有
5 N, B2 P. s2 `1 z一个很大的作用，就是自动为我们产生代码。如果说模板可以为我们产生各种型别的代码(型别替换)，
* w* K6 @& w3 ^) D那么宏其实可以为我们在符号上产生新的代码(即符号替换、增加)。

关于宏的一些语法问题，可以在google上找到。相信我，你对于宏的了解绝对没你想象的那么多。如果你
还不知道#和##，也不知道prescan，那么你肯定对宏的了解不够。

我稍微讲解下宏的一些语法问题(说语法问题似乎不妥，macro只与preprocessor有关，跟语义分析又无关)：

1. 宏可以像函数一样被定义，例如：
#define min(x,y) (x 但是在实际使用时，只有当写上min()，必须加括号，min才会被作为宏展开，否则不做任何处理。

2. 如果宏需要参数，你可以不传，编译器会给你警告(宏参数不够)，但是这会导致错误。如C++书籍中所描
述的，编译器(预处理器)对宏的语法检查不够，所以更多的检查性工作得你自己来做。

3. 很多程序员不知道的#和##
#符号把一个符号直接转换为字符串，例如：
#define STRING(x) #x
const char *str = STRING( test_string ); str的内容就是"test_string"，也就是说#会把其后的符号
% s8 X5 ^$ S# L+ w5 d2 n8 Q直接加上双引号。
: R( V0 Z3 ]. s& ]( Q4 T##符号会连接两个符号，从而产生新的符号(词法层次)，例如：
#define SIGN( x ) INT_##x
int SIGN( 1 ); 宏被展开后将成为：int INT_1;

4. 变参宏，这个比较酷，它使得你可以定义类似的宏：
#define LOG( format, ... ) printf( format, __VA_ARGS__ )
LOG( "%s %d", str, count );
$ |: w% Z  A% d; C- e, n__VA_ARGS__是系统预定义宏，被自动替换为参数列表。

5. 当一个宏自己调用自己时，会发生什么？例如：
#define TEST( x ) ( x + TEST( x ) )
TEST( 1 ); 会发生什么？为了防止无限制递归展开，语法规定，当一个宏遇到自己时，就停止展开，也就是
2 v: w; w; D) P说，当对TEST( 1 )进行展开时，展开过程中又发现了一个TEST，那么就将这个TEST当作一般的符号。TEST(1)
最终被展开为：1 + TEST( 1) 。

6. 宏参数的prescan，
* G, s* _! v. n- @2 }. [当一个宏参数被放进宏体时，这个宏参数会首先被全部展开(有例外，见下文)。当展开后的宏参数被放进宏体时，
2 y% S1 r" u8 D7 X预处理器对新展开的宏体进行第二次扫描，并继续展开。例如：
#define PARAM( x ) x
0 O2 t3 h5 F3 q# f#define ADDPARAM( x ) INT_##x
PARAM( ADDPARAM( 1 ) );
7 e+ V' W, o4 |/ A. ~因为ADDPARAM( 1 ) 是作为PARAM的宏参数，所以先将ADDPARAM( 1 )展开为INT_1，然后再将INT_1放进PARAM。

例外情况是，如果PARAM宏里对宏参数使用了#或##，那么宏参数不会被展开：
7 {- {2 x( Q7 E#define PARAM( x ) #x
7 o7 {7 N8 h3 _* b  X) ^3 k0 |- W#define ADDPARAM( x ) INT_##x
PARAM( ADDPARAM( 1 ) ); 将被展开为"ADDPARAM( 1 )"。

使用这么一个规则，可以创建一个很有趣的技术：打印出一个宏被展开后的样子，这样可以方便你分析代码：
#define TO_STRING( x ) TO_STRING1( x )
7 J2 @* M3 n9 ]# U  R#define TO_STRING1( x ) #x
TO_STRING首先会将x全部展开(如果x也是一个宏的话)，然后再传给TO_STRING1转换为字符串，现在你可以这样：
const char *str = TO_STRING( PARAM( ADDPARAM( 1 ) ) );去一探PARAM展开后的样子。

7. 一个很重要的补充：就像我在第一点说的那样，如果一个像函数的宏在使用时没有出现括号，那么预处理器只是
将这个宏作为一般的符号处理(那就是不处理)。

我们来见识一下宏是如何帮助我们自动产生代码的。如我所说，宏是在符号层次产生代码。我在分析Boost.Function
' }9 g7 K$ A' a0 l' @! C* P$ ^% M& E模块时，因为它使用了大量的宏(宏嵌套，再嵌套)，导致我压根没看明白代码。后来发现了一个小型的模板库ttl，说的
是开发一些小型组件去取代部分Boost(这是一个好理由，因为Boost确实太大)。同样，这个库也包含了一个function库。
4 l3 L! N' L& j: k- j+ y0 }这里的function也就是我之前提到的functor。ttl.function库里为了自动产生很多类似的代码，使用了一个宏：

#define TTL_FUNC_BUILD_FUNCTOR_CALLER(n) /
# V2 P$ o" d5 B0 D+ k4 [template< typename R, TTL_TPARAMS(n) > /
struct functor_caller_base##n /
///...
该宏的最终目的是：通过类似于TTL_FUNC_BUILD_FUNCTOR_CALLER(1)的调用方式，自动产生很多functor_caller_base模板：
6 b4 F0 U# V, A  `template struct functor_caller_base1
4 R+ ?* \  F- |& ~7 A# ytemplate struct functor_caller_base2
2 i7 D0 L( x# @3 dtemplate struct functor_caller_base3
///...
/ _$ W' [) [1 p/ U% X那么，核心部分在于TTL_TPARAMS(n)这个宏，可以看出这个宏最终产生的是：
typename T1
typename T1, typename T2
8 r$ ^- X" O6 W# H8 |# `' O- Atypename T1, typename T2, typename T3
///...
我们不妨分析TTL_TPARAMS(n)的整个过程。分析宏主要把握我以上提到的一些要点即可。以下过程我建议你翻着ttl的代码，
7 S. X: r1 Q- M* R& N0 P- m! [相关代码文件：function.hpp, macro_params.hpp, macro_repeat.hpp, macro_misc.hpp, macro_counter.hpp。

so, here we go

分析过程，逐层分析，逐层展开，例如TTL_TPARAMS(1)：

#define TTL_TPARAMS(n) TTL_TPARAMSX(n,T)
=> TTL_TPARAMSX( 1, T )
: Z. v  y1 J# X: i; I#define TTL_TPARAMSX(n,t) TTL_REPEAT(n, TTL_TPARAM, TTL_TPARAM_END, t)
=> TTL_REPEAT( 1, TTL_TPARAM, TTL_TPARAM_END, T )
#define TTL_TPARAM(n,t) typename t##n,
#define TTL_TPARAM_END(n,t) typename t##n
#define TTL_REPEAT(n, m, l, p) TTL_APPEND(TTL_REPEAT_, TTL_DEC(n))(m,l,p) TTL_APPEND(TTL_LAST_REPEAT_,n)(l,p)
/ ~4 D; y" O5 ?5 E7 v) Q( t注意，TTL_TPARAM, TTL_TPARAM_END虽然也是两个宏，他们被作为TTL_REPEAT宏的参数，按照prescan规则，似乎应该先将
$ _3 W$ ^( F! U& v这两个宏展开再传给TTL_REPEAT。但是，如同我在前面重点提到的，这两个宏是function-like macro，使用时需要加括号，
如果没加括号，则不当作宏处理。因此，展开TTL_REPEAT时，应该为：
=> TTL_APPEND( TTL_REPEAT_, TTL_DEC(1))(TTL_TPARAM,TTL_TPARAM_END,T) TTL_APPEND( TTL_LAST_REPEAT_,1)(
8 a4 B, j; r" ~3 X( O) F8 cTTL_TPARAM_END,T)
$ k' l7 z3 B9 x9 b. h+ h/ z/ V9 G这个宏体看起来很复杂，仔细分析下，可以分为两部分：
7 A* V0 v/ y  G5 K, G3 h# {$ }) ^; cTTL_APPEND( TTL_REPEAT_, TTL_DEC(1))(TTL_TPARAM,TTL_TPARAM_END,T)以及
' t6 h3 v  S& ^3 c2 qTTL_APPEND( TTL_LAST_REPEAT_,1)(TTL_TPARAM_END,T)
) p6 S1 a8 S) I/ C先分析第一部分：
. @! e3 r+ P: U: U#define TTL_APPEND( x, y ) TTL_APPEND1(x,y) //先展开x,y再将x,y连接起来
#define TTL_APPEND1( x, y ) x ## y
#define TTL_DEC(n) TTL_APPEND(TTL_CNTDEC_, n)
根据先展开参数的原则，会先展开TTL_DEC(1)
=> TTL_APPEND(TTL_CNTDEC_,1) => TTL_CNTDEC_1
#define TTL_CNTDEC_1 0 注意，TTL_CNTDEC_不是宏，TTL_CNTDEC_1是一个宏。
=> 0 ， 也就是说，TTL_DEC(1)最终被展开为0。回到TTL_APPEND部分：
=> TTL_REPEAT_0 (TTL_TPARAM,TTL_TPARAM_END,T)
#define TTL_REPEAT_0(m,l,p)
2 n- o" p3 p# y' yTTL_REPEAT_0这个宏为空，那么，上面说的第一部分被忽略，现在只剩下第二部分：
! X% R4 j& D7 n# i. p8 pTTL_APPEND( TTL_LAST_REPEAT_,1)(TTL_TPARAM_END,T)
=> TTL_LAST_REPEAT_1 (TTL_TPARAM_END,T) // TTL_APPEND将TTL_LAST_REPEAT_和1合并起来
#define TTL_LAST_REPEAT_1(m,p) m(1,p)
5 @. V" U6 M1 `5 D$ [% D" E$ s=> TTL_TPARAM_END( 1, T )
#define TTL_TPARAM_END(n,t) typename t##n
. a8 u3 T9 {" n2 J# U1 G5 q$ ~$ p=> typename T1 展开完毕。

虽然我们分析出来了，但是这其实并不是我们想要的。我们应该从那些宏里去获取作者关于宏的编程思想。很好地使用宏
看上去似乎是一些偏门的奇技淫巧，但是他确实可以让我们编码更自动化。

7 t6 L2 z( \2 p( f) Y: K* e% K7 ]* f

kenson

1 h3 w- L9 W' c
有关VA_LIST的用法--变参函数的实现

VA_LIST 是在C语言中解决变参问题的一组宏 VA_LIST的用法：      
       （1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针
9 S7 K5 x* \; b1 Y9 \( l       （2）然后用VA_START宏初始化变量刚定义的VA_LIST变量，这个宏的第二个参数是第一个可变参数的前一个参数，是一个固定的参数。
       （3）然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型。
       （4）最后用VA_END宏结束可变参数的获取。然后你就可以在函数里使用第二个参数了。如果函数有多个可变参数的，依次调用VA_ARG获取各个参数。 VA_LIST在编译器中的处理： （1）在运行VA_START(ap,v)以后，ap指向第一个可变参数在堆栈的地址。
4 j$ F1 D3 _- U- d- }2 U0 X* t（2）VA_ARG()取得类型t的可变参数值，在这步操作中首先apt = sizeof(t类型)，让ap指向下一个参数的地址。然后返回ap-sizeof(t类型)的t类型*指针，这正是第一个可变参数在堆栈里的地址。然后用*取得这个地址的内容。
# o& _5 X) N0 {0 f* H（3）VA_END(),X86平台定义为ap = ((char*)0)，使ap不再指向堆栈，而是跟NULL一样，有些直接定义为((void*)0)，这样编译器不会为VA_END产生代码，例如gcc在Linux的X86平台就是这样定义的。 要注意的是：由于参数的地址用于VA_START宏，所以参数不能声明为寄存器变量，或作为函数或数组类型。 使用VA_LIST应该注意的问题：
0 W% Z; I% p$ [$ G/ B2 z' @   （1）因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能地识别不同参数的个数和类型. 也就是说,你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的.
* m8 {$ |0 v+ `% l0 v: x- ?6 Q   （2）另外有一个问题,因为编译器对可变参数的函数的原型检查不够严格,对编程查错不利.不利于我们写出高质量的代码。
& Y, `( \# L: W) G: Z小结：可变参数的函数原理其实很简单，而VA系列是以宏定义来定义的，实现跟堆栈相关。我们写一个可变参数的C函数时，有利也有弊,所 以在不必要的场合，我们无需用到可变参数，如果在C++里，我们应该利用C++多态性来实现可变参数的功能，尽量避免用C语言的方式来实现。 示例代码:
7 F+ Z4 e3 P3 V  T7 U# B1 L#include<stdio.h>
8 W5 t9 m6 u% h6 {8 \: L3 C#include<stdarg.h>
void simple_va_fun(int start,...)
{
; x4 z- c, b" J     va_list arg_ptr;
0 u% x$ k6 V8 m# B; O     int nArgValue = start;
     int nArgCount = 0;
     va_start(arg_ptr,start);
     do
     {
     ++nArgCount;
      printf("the %d the arg:%d\n",nArgCount,nArgValue);
       nArgValue=va_arg(arg_ptr,int);
7 R$ n$ z! {+ L  s    }while(nArgValue != -1);
5 I4 n$ h0 {7 n9 U2 Z    return;
( \. H- [, B$ ^  ^4 ^/ T     }
main()
{
simple_va_fun(100,-1);
, ?8 ?1 B3 k" Msimple_va_fun(100,200,-1);
getchar();
      }
///////////////////
5 u; O# e" `2 ~9 A& H& mint writeMultiString(void *c, ...)
! ^2 t+ r' m7 }/ h. S" T  o4 y& X{
1 c! ?! e1 A! p% \    va_list ap;
    const char *str;
: c% I3 D9 R8 Y' R7 H
& @3 i+ l3 N% L4 A* ^( h    va_start(ap, c);
3 q/ W/ Q2 [: Z* ~) O    str = va_arg(ap, const char *);

    while (str != NULL)
    {
- a2 }. r- X' c$ B  `  J        fputs(str, (FILE *)c);
2 U, S$ ~) h# B4 i. V/ C  H        str = va_arg(ap, const char *);
    }

6 M& k" B6 S! O; b$ X4 l% D    va_end(ap);
    return 0;
4 g+ N& Y8 w3 k}

kenson

! `0 K1 X0 N/ D: R9 t
0 s; a& V! N& hva_list 详解

$ I. g; w% Y2 U# k$ \VA_LIST 是在C语言中解决变参问题的一组宏

  a6 D+ ~; `$ d+ T7 R& A) W% J他有这么几个成员：

1） va_list型变量：
! a' l# F& \) u
#ifdef  _M_ALPHA
typedef struct {
; G: J: \7 P! A0 w7 b        char *a0;       /* pointer to first homed integer argument */
$ t" ^  t! S. `        int offset;     /* byte offset of next parameter */
5 {5 B# }  R% ]$ q0 a  K# X9 F1 L} va_list;
#else
typedef char *  va_list;
: X  K* q& M1 k7 O+ ~1 _8 d. P#endif

2）_INTSIZEOF 宏，获取类型占用的空间长度，最小占用长度为int的整数倍：
# a: I. s# n* v* F/ q$ [* _8 ~9 P
#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

3）VA_START宏，获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，v是可变参数最左边的参数）：
. l. G0 `* M& k2 ~" A1 F# `
5 J2 g" S6 b+ E/ ^' O#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )
6 G4 r' f9 J* _* P: H
: @+ o/ P% Q- v! P, P" m4）VA_ARG宏，获取可变参数的当前参数，返回指定类型并将指针指向下一参数（t参数描述了当前参数的类型）：

#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
! g0 f: W$ G5 d/ I. g
5）VA_END宏，清空va_list可变参数列表：

#define va_end(ap)      ( ap = (va_list)0 )
2 H6 U. [3 u+ f
; i/ p7 ^4 x1 r9 n$ @2 {6 }/ X5 p3 iVA_LIST的用法：      
       （1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针；
       （2）然后用VA_START宏初始化变量刚定义的VA_LIST变量；
       （3）然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用VA_ARG获取各个参数）；
       （4）最后用VA_END宏结束可变参数的获取。
使用VA_LIST应该注意的问题：
3 Z6 X0 A5 a4 k. E2 T) r8 j   （1）可变参数的类型和个数完全由程序代码控制,它并不能智能地识别不同参数的个数和类型；
   （2）如果我们不需要一一详解每个参数，只需要将可变列表拷贝至某个缓冲，可用vsprintf函数；
: H; h* m- k* t* h/ V7 B: z: e) i" _   （3）因为编译器对可变参数的函数的原型检查不够严格,对编程查错不利.不利于我们写出高质量的代码；
6 {( d6 [2 r$ R& U7 h  l$ R
# ?% T. Y" r5 h. \: T+ c4 A' ]小结：可变参数的函数原理其实很简单，而VA系列是以宏定义来定义的，实现跟堆栈相关。我们写一个可变参数的C函数时，有利也有弊,所 以在不必要的场合，我们无需用到可变参数，如果在C++里，我们应该利用C++多态性来实现可变参数的功能，尽量避免用C语言的方式来实现。