答案是D  编译预处理的时候，宏名PI将被字符串“3.14159“代替，这一替换过程称为宏展开
宏的定义格式为
#define 宏名 字符串或者字符

、、、、、、、、、、、、、、、、、、、、、、、、

1.要明白C语言中的宏机制：
    c程序编译分过程分为三个步骤：（1）预处理；（2）编译；（3）链接。在预处理阶段，编译器中的预处理器会将你定义的宏展开，即 原封不动的替换宏的定义，只是在处理文本，就像word里面的替换一样。
2.然后要明白常量的含义：
   常量是在程序编译以后对应的一块内存存储区域，这块存储区域可读不可写。将变量写进存储区域，要经过编译成汇编，在汇编成机器语言（二进制的指令），然后链接，当运行时才会真正写内存。所有工作必须在预处理之后。常量可以这样定义： const double pi=3.1415;

理解的关键是：预处理只处理文本，只做文本替换。

//////////////////////////////////////////////////////

宏和全局变量的区别？

区别在于宏定义没有类型

比如宏定义#define pi 3.1415926这里的pi并没有类型

而全局变量放在主函数的前面 double pi=3.1415926;

建议你少用宏定义，因为宏定义存在很强的安全隐患，没有类型的变量当然在很

多时候会造成很多错误了，而且所有的宏定义都可以用其他的方式代替，一般情

况下更简便，只不过大多初学者以为宏定义看起来似乎很酷，所以初学的时候都

喜欢用，其实现在基本上已经没什么人用宏定义了，用了宏定义的程序健壮性不

行

///////////////////////////////////////////////

                                        宏定义
        1.0、宏定义，即宏替换、宏代换，简称宏。
                 宏结构：
                             #define  宏名部分  宏体部分
                 预处理(预编译)，即宏展开，用具体内容替换宏名部分。预处理在程序编译过程中不做语法检查。
                 使用规则：
                        1、宏名一般用大写字母构成。
                        2、宏定义尾不加分号。
                        3、宏定义在函数外，其作用域始于该宏之后的程序，终于#undef命令或程序尾部。宏定义一般位于文件开始位置。
                       4、宏定义可以嵌套。
                       5、宏定义不分配内存，变量定义分配内存。
               使用宏之目的：
                       1、使程序标准化，提高程序通用性、易读性。
                       2、减少写程序过程中之输入错误。
                       3、方便程序的修改。
       1.1、不带参数之宏定义：
                1.1.0、格式：
            #define 标识符 字符串         //标识符=宏名，字符串=宏体。
               1.1.1、示例：
                例：#defin PI 3.14159      //PI=宏名，3.14159=宏体。预处理后，程序内之PI被3.14159替换。
                        #define UINT long      //UINT=宏名，long=宏体。预处理后，程序内之UINT被long替换。
               1.1.2、使用规则：
                       1、字符串内不能包含宏。
                       2、宏定义不分配内存，变量定义分配内存。
               1.1.3、错误示例：
                       1、#define NAME "lili"           //" "号内的内容不会被替换。
                       2、#define 0x pi                      //宏名部分必须是合法用户标识符。
                       3、#define NAME "li              //" "号要配对使用。
       1.2、带参数之宏定义：
               1.2.0、格式 :
                       #define  宏名(参数1, 参数2, ...)   字符串       //预处理时，一般字符串被替换，参数也被替换。
               1.2.1、示例：
                       #define S(r) ((r)*(r))                                          //带参数宏使用时类似函数调用，有虚实结合过程。
               1.2.2、使用规则：
                       1、宏名紧挨着参数括号，其间不能出现空格。
                       2、宏替换只是替换，不做计算，也不做表达式求解。
                       3、宏的参数一般用圆括号括起来，可防止出错。
                       3、宏之虚实结合无类型，不存在类型转换
               1.2.3、带参数宏的特征：
                       1、宏替换发生于编译前，不分配内存；函数调用于程序运行之时，要分配内存。
                       2、宏可返回多个值，函数只能返回一个值。
                       3、宏展开则源程序变大，函数调用不影响源程序大小。
                       4、宏展开不占运行时间，只占编译时间；函数调用占运行时间(分配内存、保护现场、值传递、返回值)
       1.3、带参数宏定义中的#用法：
               1.3.1、#将宏定义之参数用""括起来
               1.3.2、示例：
                        #define STR(a#b)  #a#b              //STR(a#b)被替换为"a#b"
                        #define S(name)  #name             //S(name)被替换为"name"
       1.4、带参数宏定义中的##用法：
            1.4.1、##将其前面字符与参数连接成新字符串。
            1.4.2、示例：
                        #define FUN(str)  Name##str       //FUN(str)被替换为Namestr。    ##str=str
                        #define FUN(a,b) vo##a##b()      //FUN(id ma,in)被替换为void main()。   ##a=id ma，   ##b=in
       1.5、多行宏定义：
                        #define count(m,n) for(int i=0; i<(n);++i) \
                        { \
                        m+=i; \
                        }                                 //宏定义结束之前每行尾加\。