预处理

     预处理是编译之前的扫描，预处理完成后才是编译
     在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程是读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行相应的转换。预处理过程还会删除程序中的注释和多余的空白字符。
       预处理指令是以#号开头的代码行。

       #号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。

      根据预处理指令的类型，可以分为三类，条件编译，宏替换，文件包含。下面是全部的预处理指令（根据ANSI标准的定义）

        指令             用途
         #           空指令，无任何效果
         #include    包含一个源代码文件
         #define     定义宏
         #undef      取消已定义的宏
         #if         如果给定条件为真，则编译下面代码
         #ifdef      如果宏已经定义，则编译下面代码
         #ifndef     如果宏没有定义，则编译下面代码
         #elif       如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
         #endif      结束一个#if……#else条件编译块
         #error      停止编译并显示错误信息

         #else

         #line

         #pragma

         

一、文件包含

         #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。

      文件包含命令的功能是把指定的文件插入该命令行位置取代该命令行， 从而把指定的文件和当前的源程序文件连成一个源文件。在程序设计中，文件包含是很有用的。 一个大的程序可以分为多个模块，由多个程序员分别编程。 有些公用的符号常量或宏定义等可单独组成一个文件， 在其它文件的开头用包含命令包含该文件即可使用。这样，可避免在每个文件开头都去书写那些公用量， 从而节省时间，并减少出错。

      在程序中包含头文件有两种格式：

       

   #include <my.h>
   #include "my.h"

        使用尖括号表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的，一般的叫做标准目录)， 而不在源文件目录去查找； 使用双引号则表示首先在当前的源文件目录中查找，若未找到才到包含目录中去查找。 用户编程时可根据自己文件所在的目录来选择某一种命令形式。

       采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。

二、宏

         宏定义了一个代表特定内容的标识符。预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。宏最常见的用法是定义代表某个值的全局符号。宏的第二种用法是定义带参数的宏，这样的宏可以象函数一样被调用，但它是在调用语句处展开宏，并用调用时的实际参数来代替定义中的形式参数。

        记住，宏就是替代作用，总的来说注意五个知识点，带参数的宏定义，不带参数的宏定义，宏定义中出现的“\”表示连接，“#”表示紧跟的参数转变为字符，“##”表示参数的连接在一起。

        1.不带参数#define指令

        #define预处理指令是用来定义宏的。该指令最简单的格式是：首先声明一个标识符，然后给出这个标识符代表的代码。在后面的源代码中，就用这些代码来替代该标识符。这种宏把程序中要用到的一些全局值提取出来，赋给一些记忆标识符。

            #define MAX_NUM 10
            int array[MAX_NUM];
            for(i=0;i<MAX_NUM;i++)  /*……*/

        在这个例子中，对于阅读该程序的人来说，符号MAX_NUM就有特定的含义，它代表的值给出了数组所能容纳的最大元素数目。程序中可以多次使用这个值。作为一种约定，习惯上总是全部用大写字母来定义宏，这样易于把程序宏标识符和一般变量标识符区别开来。如果想要改变数组的大小，只需要更改宏定义并重新编译程序即可。

        宏表示的值可以是一个常量表达式，其中允许包括前面已经定义的宏标识符。例如：

           

            #define ONE 1
            #define TWO 2
            #define THREE (ONE+TWO)

        注意上面的宏定义使用了括号。尽管它们并不是必须的。但出于谨慎考虑，还是应该加上括号的。例如：

            six=THREE*TWO;

        预处理过程把上面的一行代码转换成：

            six=(ONE+TWO)*TWO;

        如果没有那个括号，就转换成six=ONE+TWO*TWO;

        宏还可以代表一个字符串常量，例如：

           

             #define VERSION "Version 1.0 Copyright(c) 2003"

        如果一个串长度一行不能容纳，可以在结尾用“\”续航，例如：

               #define INFO  "this is a very very long \
               string that is used as an example“

    2. 带参数的#define指令

         带参数宏定义的一般形式为：#define 宏名（形参表）  字符串 ；在字符串中含有各个形参。带参宏调用的一般形式为：宏名（实参表）。

        带参数的宏和函数调用看起来有些相似。看一个例子：

           

     #define Cube(x) (x)*(x)*(x)

        可以时任何数字表达式甚至函数调用来代替参数x。这里再次提醒大家注意括号的使用。宏展开后完全包含在一对括号中，而且参数也包含在括号中，这样就保证了宏和参数的完整性。看一个用法：

           

      int num=8+2;
      volume=Cube(num);

        展开后为(8+2)*(8+2)*(8+2);

        如果没有那些括号就变为8+2*8+2*8+2了。

        下面的用法是不安全的：

            volume=Cube(num++);

        如果Cube是一个函数，上面的写法是可以理解的。但是，因为Cube是一个宏，所以会产生副作用。这里的擦书不是简单的表达式，它们将产生意想不到的结果。它们展开后是这样的：

            volume=(num++)*(num++)*(num++);

        很显然，结果是10*11*12,而不是10*10*10;

        那么怎样安全的使用Cube宏呢？必须把可能产生副作用的操作移到宏调用的外面进行：

           

            int num=8+2;
            volume=Cube(num);
            num++;

      多参数的宏定义如：

           #define KUAN(x,y)   x*x;

      那么KUAN（2，3）；展开为：2＊2；

    3.#运算符

    出现在宏定义中的#运算符把跟在其后的参数转换成一个字符串。有时把这种用法的#称为字符串化运算。例如：       

           #define PASTE(n) "adhfkj"#n
            main()
            {
               printf("%s\n",PASTE(15));
            }

        宏定义中的#运算符告诉预处理程序，把源代码中任何传递给该宏的参数转换成一个字符串。所以输出应该是adhfkj15。

    4.##运算符

     ##运算符用于把参数连接到一起。预处理程序把出现在##两侧的参数合并成一个符号。看下面的例子：

           

            #define NUM(a,b,c) a##b##c
            #define STR(a,b,c) a##b##c
            main()
            {
                printf("%d\n",NUM(1,2,3));
                printf("%s\n",STR("aa","bb","cc"));
            }

        最后程序的输出为:

                 123

                 aabbcc

       千万别担心，除非需要或者宏的用法恰好和手头的工作相关，否则很少有程序员会知道##运算符。绝大多数程序员从来没用过它。

三、条件编译指令

       条件编译指令将决定那些代码被编译，而哪些是不被编译的。可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。

        我们一般的习惯是把函数的声明，结构体的定义放在头文件里面，如果不使用条件编译，多个头文件可能重复包含，那么编译就通不过，所以必须使用条件编译。

    下面有三种情况：

    1.#if 常量表达式 

程序段1 

#else 

程序段2 

#endif 

   它的功能是，如常量表达式的值为真(非0)，则对程序段1 进行编译，否则对程序段2进行编译。因此可以使程序在不同条件下，完成不同的功能

    例如;

#if 1
   printf("this is ture");
#else
    printf(“this is false”);
#endif

    2.第二种形式： 

#ifndef  标识符 

程序段1 

#else 

程序段2 

#endif 

它的功能是，如果标识符未被#define命令定义过则对程序段1进行编译， 否则对程序段2进行编译。

    3.第三种形式

        #ifdef 标识符 

    程序段1 
#else 
    程序段2 
#endif 

它的功能是，如果标识符已被 #define命令定义过则对程序段1进行编译；否则对程序段2进行编译。如果没有程序段2(它为空)，本格式中的#else可以没有， 即可以写为： 

#ifdef 标识符 

     程序段

 #endif 

四.  其他一些标准指令

    #error指令将使编译器显示一条错误信息，然后停止编译。

     #line指令可以改变编译器用来指出警告和错误信息的文件号和行号。

     #pragma指令没有正式的定义。编译器可以自定义其用途。典型的用法是禁止或允许某些烦人的警告信。但是以上的预处理命令基本上没有用过，但是注意用法1，在内存对齐的时候可能要用到。

1. #pragma pack()

     注：如果设置的值比结构体中字节最长的类型还要大，则这个变量(注意仅针对这一个变量)只按照它的字节长度对齐，即不会出现内存浪费的情况。请参见(4)。这个在内存对齐的应用中很常见。

(1)

#pragma pack(1)        //每个变量按照1字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 1

}a;

sizeof(a)==5

(2)

#pragma pack(2)        //每个变量按照2字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 2

}a;

sizeof(a)==6

(3)

#pragma pack(4)        //每个变量按照4字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 4

}a;

sizeof(a)==8

(4)

#pragma pack()        //默认，相当于#pragma pack(8) 每个变量按照8字节对齐

struct A

{

char x;    //aligned on byte boundary 0

int y;     //aligned on byte boundary 4

}a;

sizeof(a)==8

但是这里y的大小是4字节，所以不会按照8字节对齐，否则将造成1个int空间的浪费

2. #pragma warning指令

该指令允许有选择性的修改编译器的警告消息的行为

指令格式如下:

#pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list...]

#pragma warning( push[ ,n ] )

#pragma warning( pop )

主要用到的警告表示有如下几个:

once:只显示一次(警告/错误等)消息

default:重置编译器的警告行为到默认状态

1,2,3,4:四个警告级别

disable:禁止指定的警告信息

error:将指定的警告信息作为错误报告

如果大家对上面的解释不是很理解,可以参考一下下面的例子及说明

#pragma warning( disable : 4507 34; once : 4385; error : 164 )

等价于：

#pragma warning(disable:4507 34) // 不显示4507和34号警告信息

#pragma warning(once:4385)        // 4385号警告信息仅报告一次

#pragma warning(error:164)        // 把164号警告信息作为一个错误。

同时这个pragma warning 也支持如下格式：

#pragma warning( push [ ,n ] )

#pragma warning( pop )

这里n代表一个警告等级(1---4)。

#pragma warning( push )保存所有警告信息的现有的警告状态。

#pragma warning( push, n)保存所有警告信息的现有的警告状态，并且把全局警告

等级设定为n。  

#pragma warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的

一切改动取消。例如：

#pragma warning( push )

#pragma warning( disable : 4705 )

#pragma warning( disable : 4706 )

#pragma warning( disable : 4707 )

#pragma warning( pop )

在这段代码的最后，重新保存所有的警告信息(包括4705，4706和4707)

在使用标准C++进行编程的时候经常会得到很多的警告信息,而这些警告信息都是不必要的提示,

所以我们可以使用#pragma warning(disable:4786)来禁止该类型的警告

在vc中使用ADO的时候也会得到不必要的警告信息,这个时候我们可以通过

#pragma warning(disable:4146)来消除该类型的警告信息

3.#pragma comment

The following pragma causes the linker to search for the EMAPI.LIB library while linking. The linker searches first in the current working directory and then in the path specified in the LIB environment variable:

#pragma comment( lib, "emapi" )

4.#pragma deprecated

When the compiler encounters a deprecated symbol, it issues C4995:

void func1(void) {}

void func2(void) {}

int main() {

   func1();

   func2();

   #pragma deprecated(func1, func2)

   func1();   // C4995

   func2();   // C4995

}

5.#pragma message

The following code fragment uses the message pragma to display a message during compilation:

#if _M_IX86 == 500

#pragma message( "Pentium processor build" )

#endif