【C陷阱和缺陷】预处理器

一，概念      

        宏只是对程序的文本起作用，提供了一种对组成程序的字符进行变换的方式，而并不作用域程序中的对象，因此可以使一段看上去完全不合法的代码变成一个有效的程序，也能使一段看上去无害的代码编程一个怪物。

二，细节

        1）宏定义中的空格 （注意带参数的宏）

              如果函数无参，则调用时只需在函数名后面加一对括号，如果一个宏不带参数，则只需要使用宏名即可，括号无关紧要。

              #define  f  (x)  ((x)-1)的含义：

                       用f代表(x) ((x)-1) 而不是用f (x) 代表((x)-1),因为f后面有空格！

                       宏定义时空格会影响其含义，但调用时空格无关紧要。

             如：#define fun(x)   ((x)-1) 调用时，fun(3) 和fun (3)的结果都是2。

        2）宏并不是函数 （自增、自减作为参数需谨慎）

              宏定义中每个参数最好用括号括起来，整个表达式也用括号括起来。

              但即使宏定义中各参数和整个表达式都被括起来，也仍然可能有其他问题存在。

             例如：#define max(a,b) ((a)>(b)?(a): (b))

                         当a大于b时，如果a是一个自增表达式，则a被重复求值，造成最终结果错误。

                         我们可以这样实现toupper函数：

char toupper(int c)

{

         if(c>='a' && c<='z')

                   c -= 'a'-'A';

         return c;

}

            用宏定义实现，要比调用函数快得多，但很危险：

             #define toupper(c) ((c)>=’a’ && c<=’z’ ?(c)-(‘a’-‘A’): (c))

             当这样调用：toupper(*p++)时，结果错误！

       3）宏并不是语句 （宏中包含C语句需要注意）

              assert(x>y); assert为一个宏，当参数为0时报告断言失败的文件名和失败处的行号，当参数不为0时，什么也不做。

              如果如下定义： #define assert(e) if(!e) assert_error(__FILE__,__LINE__)

              当如下调用时出错：

              if(x>0 && y>0)

                          assert(x>y);

              else

                          assert(y>x);

              因为展开后，if else的流程结构出错。

            修改：

                    定义时为其加括号：#define assert(e) (if(!e) assert_error(__FILE__,__LINE__))

                    但上面的调用时，assert的句尾有分号，造成语法错误。

                    其正确定义如下：

                           #define assert1(e) ( (void)( (e)||_assert_error(__FILE__,__LINE__) ) )

                    这个定义不是语句，而是类似一个表达式。

      4）宏并不是类型定义 

            宏的一个常见用途是使多个不同变量的类型可以在一个地方说明:

                     #define FOOTYPE struct foo

                     FOOTYPE a; FOOTYPE b,c; 之后a,b,c的类型可以一改全改。

          但typedef 更通用一些！

                 #define T1 struct foo *      当试图声明多个变量时，问题就来了：

                 T1 a,b ;  被扩展为 struct foo * a, b; 此时a 为指针，而b为结构体。

               而使用下面的定义：typedef struct foo *T2;

               T2 c,d 此时c、d都为指向结构体的指针，T2的行为完全与一个新类型的行为相同。

三，习题

        1） 用宏来实现max，其中max的参数都是整数，要求这些整型参数只被求值一次。

              Answer：因为每个参数值都会被使用两次，一次是在参数比较时，一次是在把它作为结果时返回时。所以，应该把每个参数值存储在一个临时变量里。

              但我们无法在一个C表达式内部声明一个临时变量，而且即使能声明一个临时变量多次调用max时会造成重复定义。所以不能将这些变量作为宏定义的一部分进行声明，而应在宏定义之外。当max用于不只一个程序文件时，应该把这些变量声明为static，以避免命名冲突。

              static int tmp1, tmp2;

              #define max(p,q) (tmp1=(p), tmp2=(q), tmp1>tmp2?tmp1:tmp2)

             这时max不能嵌套调用，否则不能正常工作。

         2）#define f (x) ((x)-1) 是否是一个合法的表达式？

           Answer：

               （1）当x是类型名时可以。Eg: #define x int 则(int)((int)-1)表示将-1进行两次int类型的强制转换。

               （2）当x是个函数指针，且x指向某函数指针数组的某个元素时，可以。这时表达式可以解释为调用x指向的函数，而((x)-1)为函数的参数。假定x的类型时T，即T x; 其中T如下定义：    

                          typedef void (*T)(void*) ， 因为void*可以被强制转换为T类型。但不能如下定义：

                          typedef void(*T)(T),因为只有T被声明后才能这样定义T！