预定义符号是C标准规定的宏定义符号，有以下5种

1. __FILE__（进行编译的源文件名称）

2. __LINE__（文件当前行号）

3. __DATE__（文件被编译的日期）

4. __TIME__（文件被编译的时间）

5. __STDC__（如果编译器遵循ANSI C，值为1，否则未定义）

2. #define

#define定义的标识符常量和宏都会在在预处理阶段，对程序中所有出现的标识符，宏名都会被定义的内容替换掉。

2.1 #define定义的标识符常量

格式：#define 标识符字符串

其中，标识符为符号常量，字符串可以是常数、表达式、格式串等。

#define MAX 1000 //用MAX代替1000
#define reg register //为register这个关键字，创建一个简短的名字
#define do_forever for(;;) //用更形象的符号来替换一种实现 
#define CASE break;case //在写case语句的时候自动把 break写上。 
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \ date:%s\ttime:%s\n" ,\ __FILE__,__LINE__ , \ __DATE__,__TIME__ )

2.2 #define定义宏

#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（ macro ）或定义宏（define macro ）。

格式： #define 宏名( 参数列表 ) 字符串

其中的参数列表是一个由逗号隔开的符号表，它们可能出现在 字符串 中。

注意：

1.参数列表的左括号必须与宏名紧邻，如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分

2.所以用于对数值表达式进行求值的宏定义都应该对参数和替换的整体加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

#define add(x,y) ((x)+(y)) //例子

2.3 #define替换规则

在程序中扩展 #define 定义符号和宏时，需要涉及几个步骤：

在调用宏时，首先对参数进行检查，看看是否包含任何由 #define 定义的符号。如果是，它们首先被替换。

替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

最后，再次对结果文件进行扫描，看看它是否包含任何由 #define 定义的符号。如果是，就重复上述处理过程。

注意：

宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

2.4 #和##

1.#用于将宏定义中的传入参数名转换成用一对双引号括起来参数名字符串（字符串化）。#只能用于有传入参数的宏定义中，且必须置于宏定义体中的参数名前。

#include<stdio.h>
#define PRINT(N, FORMAT) printf("the value of "#N" is "FORMAT"\n", N) 
int main()
{ 
    int a = 10; 
    PRINT(a, "%d"); 
    return 0; 
}

运行结果：

2.##用于把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。

#include<stdio.h> 
#define CAT(Class, Num) Class##Num //把位于它两边的符号合成一个符号 
int main() 
{ 
    int ClassNum = 100; 
    printf("%d", CAT(Class, Num)); 
    return 0; 
}

运行结果： 100

2.5 带副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。

int x = 0;
x+1;//不改变x本身大小，不带副作用 
x++;//改变x本身大小，带有副作用

2.6 宏和函数的比较

2.7 命名约定

        一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者。

所以我们平时的一个习惯是：

        1.把宏名全部大写

        2.函数名不要全部大写

3.#undef

#undef这条指令用于移除一个宏定义。

3.1 防止宏定义冲突

在一个程序块中用完宏定义后，为防止后面标识符冲突需要取消其宏定义。

#include <stdio.h> 
int main() 
{ 
    #define MAX 200 //定义宏 
    printf("MAX = %d\n", MAX); //MAX = 200 
    #undef MAX //移除宏 
    int MAX = 10; 
    printf("MAX = %d\n", MAX); //MAX = 10; 
    return 0; 
}

在一个程序段中使用完宏定义后立即将其取消，防止在后面程序段中用到同样的名字而产生冲突。

3.2 增强代码可读性

在同一个头文件中定义结构类型相似的对象，根据宏定义不同获取不同的对象，主要用于增强代码的可读性。

例如：在头文件student.h中定义两个学生对象（小明和小红），两个对象互不干涉。

//头文件中定义两个对象 
#ifdef MING 
#define MING_AGE 20 
#define MING_HEIGHT 175 
#endif 

#ifdef HONG 
#define HONG_AGE 19 
#define HONG_HEIGHT 165 
#endif

//源文件中使用这两个对象 
#include <stdio.h> 
#define MING 
#include "student.h" 
#undef MING 
#define HONG 
#include "student.h" 
#undef HONG 
int main() 
{ 
    printf("Xiao Ming's age is %d.\n", MING_AGE); 
    printf("Xiao Hong's age is %d.\n", HONG_AGE); 
    return 0; 
}

在一个头文件里定义的两个对象与分别在两个头文件里定义效果相同，但如果将相似的对象只用一个头文件申明，可以增强源代码的可读性。

3.3 自定义接口

将某个库函数包装成自定义接口，而只允许用户调用自定义接口，禁止直接调用库函数。

/* 
** 定义一个不易发生错误的内存分配器 
*/ 
#include <stdlib.h> 
#define malloc //防止直接调用malloc! 
#define MALLOC(num, type) (type *)alloc((num) * sizeof(type)) 
extern void *alloc(size_t size);

其中“#define malloc”是为了防止用户直接调用库函数malloc，只要包含了这个头文件alloc.h，就不能直接调用库函数malloc，而只能调用自定义函数MALLOC，如果用户要调用库函数malloc编译器会发生错误。

//自定义安全的内存分配器的实现： 
/* 
** 不易发生错误的内存分配器的实现 
*/ 
#include <stdio.h> 
#include "alloc.h" 
#undef malloc 
void *alloc(size_t size) 
{ 
    void *new_mem; new_mem = malloc(size); 
    if(new_mem == NULL) 
    { 
        printf("Out of memory!\n"); 
        exit(1); 
    } 
    return new_mem; 
}

因为在实现中需要用到库函数malloc，所以需要用这一句“#undef malloc”取消alloc.h中对malloc的宏定义。

这种技巧还是比较有意思的，用于对已经存在的库函数进行封装。而且如果包含了自定义接口文件，就不能直接调用库函数，而只能调用自定义封装的函数。

3.4 用于调试头文件中

用于调试头文件中，偶然看到这样一个代码用到了#undef，写于此作为记录：
#ifdef _DEBUG_ 
#undef THIS_FILE static char THIS_FILE[] = __FILE__; 
#define new DEBUG_NEW 
#endif

4.命令行定义

命令行定义是许多C的编译器提供的一种允许在命令行中定义符号的方式，用于启动编译过程。

例如：定义不同长度的数组（如：int arr[VALUE]），在编译程序时，可以在命令行中指定VALUE的值。

5.条件编译

条件编译用于在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃。

—般情况下，C语言源程序中的每一行代码.都要参加编译。但有时候出于对程序代码优化的考虑，希望只对其中一部分内容进行编译。此时就需要在程序中加上条件，让编译器只对满足条件的代码进行编译，将不满足条件的代码舍弃，这就是条件编译，相关的预编译指令如下：

5.1 #if defined（#ifdef）

#ifdef 标识符 (或#if defined(标识符)) //#ifdef判断后面的宏是否被定义，如果宏定义了 执行后续语句 
    程序段1 
#else //与#ifdef相对应 
    程序段2 
#endif //条件命令的结束标志

#include <stdio.h> 
#define __DEBUG__ 
int main() 
{ 
    int i = 0; 
    int arr[10] = { 0 }; 
    for (i = 0; i < 10; i++) 
    { 
        arr[i] = i; 
#ifdef __DEBUG__//如果__DEBUG__有定义，则printf("%d\n", arr[i]);参于编译 
        printf("%d\n", arr[i]); 
#else 
    printf("0\n");//否则printf("0\n");参于编译 
#endif //条件命令的结束标志 
    } 
    return 0; 
}

        #define __DEBUG__，定义没有值的DEBUG主要是用于控制调试程序的运行。当定义了DEBUG时"#ifdef DEBUG" 则执行某些调试用的代码，若把"#define DEBUG"删除了后，"#ifdef DEBUG" 就可以使程序不执行某些代码。

5.2 #if !defined（#ifndef）

//#ifndef判断后面的宏是否被定义，如果宏没有被定义 执行后续语句 
#ifndef 标识符(或#if !defined(标识符)) 
    程序段1
 #else //与#ifndef相对应 
    程序段2 
#endif // 条件命令的结束标志

#include <stdio.h> 
#define __DEBUG__ 
int main() 
{ 
    int i = 0; 
    int arr[10] = { 0 }; 
    for (i = 0; i < 10; i++) 
    { 
        arr[i] = i; 
#ifndef __DEBUG__//如果__DEBUG__没有定义，则printf("%d\n", arr[i]);参于编译
        printf("%d\n", arr[i]); 
#else 
        printf("0\n");//否则printf("0\n");参于编译 #endif //条件命令的结束标志 
    } 
    return 0; 
}

5.3 #if

#if 常量表达式 //编译预处理中的条件命令，相当于if语句 
    程序段1 
#else //与#if相对应 
    程序段2 
#endif

#include<stdio.h> 
#define M 5 
int main() 
{ 
#if M<5//M<5为printf("q\n");参与编译 
    printf("q\n"); 
#elif M==5//否则M==5为真printf("w\n");参与编译 
    printf("w\n"); 
#else//否则printf("e\n");参与编译 
    printf("e\n"); 
    return 0; 
}

5.4 嵌套指令

#if defined(OS_UNIX) 
    #ifdef OPTION1 
        unix_version_option1 (); 
    #endif 
    #ifdef OPTION2 
        unix_version_option2 (); 
    #endif 
#elif defined(OS_MSDOS) 
    #ifdef OPTION2 
        msdos_version_option2 (); 
    #endif
#endif

6.文件包含

        #include 指令可以使另外一个文件被编译，就好像它实际出现于 #include 指令的地方一样。

        这种替换方式是：预处理器先删除这条指令，并用包含文件的内容替换。（这样一个源文件被包含10次，那就实际被编译10次。）

        头文件包含方式分两种：1.本地文件包含方式#include "xxx.h"；2.库文件包含方式#include <xxx.h>

这两种查找方式的查找策略不同：

#include" xxx.h "查找策略：先去代码所在路径下查找，如果找不到，再去库目录下查找

#include< xxx.h >查找策略：直接去库目录下查找

避免头文件重复包含方式：

方式一：

#ifndef __TEST_H__ 
#define __TEST_H__ 
// 头文件的内容 
#endif //__TEST_H__

方式二：

#pragma once

7.其他预处理指令

8.#define和typedef的区别

        typedef是一种在计算机编程语言中用来声明自定义数据类型，配合各种原有数据类型来达到简化编程的目的的类型定义关键字。

        #define是预处理指令。下面让我们一起来看。

   typedef是C语言语句，其功能是用户为已有数据类型取“别名”。

例如：

typedef int INTEGER;

这以后就可用INTEGER来代替int作整型变量的类型说明了，如：

INTEGER a,b;

用typedef定义数组、指针、结构等类型将带来很大的方便，不仅使程序书写简单而且使意义更为明确，因而增强了可读性。例如：

typedef int a[10];//表示a是整型数组类型，数组长度为10。

然后就可用a说明变量，如：

a s1,s2;//完全等效于：int s1[10],s2[10] ;

同理

typedef void (*p)(void); //表示p是一种指向void型的指针类型！

#define是预处理中的宏定义命令，例如：

#define int PARA

表示在源程序中的所在int将会被PARA原样代替！

如：程序中有int a,b ;则在编译前将被替换为PAPA a,b;

#define是C中定义的语法，typedef是C++中定义的语法，二者在C++中可以通用，但#define成了预编译指令，typedef当成语句处理。Typedef和define都可以用来给对象取一个别名，但是两者却有着很大不同。

8.1 二者执行时间不同

关键字typedef在编译阶段有效，由于是在编译阶段，因此typedef有类型检查的功能。

Define则是宏定义，发生在预处理阶段，也就是编译之前，它只进行简单而机械的字符串替换，而不进行任何检查。

#define用法例子：

#define f(x) x*x 
int main( ) 
{ 
    int a=6，b=2，c； 
    c=f(a) / f(b)； 
    printf("%d \n"，c)； 
    return 0;
}

程序的输出结果是: 36，根本原因就在于#define只是简单的字符串替换，应当加个括“（X*X）”。

8.2 功能不同

Typedef用来定义类型的别名，这些类型不只包含内部类型（int，char等），还包括自定义类型（如struct），可以起到使类型易于记忆的功能。

如：

typedef int (*PF) (const char *, const char *);

定义一个指向函数的指针的数据类型PF，其中函数返回值为int，参数为const char *。

typedef 有另外一个重要的用途，那就是定义机器无关的类型，例如，你可以定义一个叫 REAL 的浮点类型，在目标机器上它可以i获得最高的精度：

typedef long double REAL;

在不支持 long double 的机器上，该 typedef 看起来会是下面这样：

typedef double REAL;

并且，在连 double 都不支持的机器上，该 typedef 看起来会是这样：

typedef float REAL;

#define不只是可以为类型取别名，还可以定义常量、变量、编译开关等。

8.3 作用域不同

#define没有作用域的限制，只要是之前预定义过的宏，在以后的程序中都可以使用。而typedef有自己的作用域。

void fun() 
{ 
    #define A int 
} 
void gun() 
{ 
    //在这里也可以使用A，因为宏替换没有作用域， 
    //但如果上面用的是typedef，那这里就不能用A ，不过一般不在函数内使用typedef 
}

8.4 对指针的操作

二者修饰指针类型时，作用不同。

Typedef int * pint； 
#define PINT int * 
Const pint p；//p不可更改，p指向的内容可以更改，相当于 int * const p; 
Const PINT p；//p可以更改，p指向的内容不能更改，相当于 const int *p；或 int const *p； 
pint s1, s2; //s1和s2都是int型指针 
PINT s3, s4; //相当于int * s3，s4；只有一个是指针。