我们正常定义一个函数需要声明参数类型，int a之类的，用宏定义函数，就不用考虑c语法。

预处理阶段工作：①将头文件展开直接放置到源文件中

                           ②宏替换

                           ③条件编译

注意：宏替换只是简单得字符串替换，且可以传递参数。

例如，#define N(n) n*10

           int b = N(a);  // 首先n替换成a，然后a*10。

易错：#define ADD(a,b) a+b

          int c = ADD(a,b) * ADD(a,b);  

/* 经过简单的替换会得到a+b*a+b，这显示不是我们想要的结果，因此加上括号保证优先级不会出错。*/

            #define ADD(a,b) (a+b) 

C预处理之宏函数

预处理过程其实还有一个条件编译的功能：可以根据不同的条件，编译不同的程序部分从而产生不同的目标代码文件，对程序的移植和调试很有用

注意：

1、宏定义是完全字符串替换 所以这里 a+b加个（）。防止一些意想不到的错误。

2、但也有好处 ：都是实现求和，定义函数求和对变量的数据类型只能与写函数的时候保持一致，而宏定义实现求和没有这个.

宏也有函数形式，可以有参数，参数可以是代码里面定义的变量 ：

#include<stdio.h>

#define R 20

#define N(n) n*10

int main(){

     int a=R;

     int b=N(a)//打印b 会发现b=20*10=200

宏函数：

eg.#define N(n) n*10

    int b=N(20)//在I文件中为：int b=20*10;

注意：#define ADD(a,b) a+b

         int e=ADD(10,20)*ADD(10,20)

        由于宏只是字符串的复制，不进行运算，所以在I文件中为：

        int e=10+20*10+20

        根据运算的优先级，要在宏定义的a+b外加上()

        宏函数对参数没有数据类型要求（区别与一般函数）

宏函数：

eg.#define N(n) n*10

    int b=N(20)//在I文件中为：int b=20*10;

注意：#define ADD(a,b) a+b

         int e=ADD(10,20)*ADD(10,20)

        由于宏只是字符串的复制，不进行运算，所以在I文件中为：

        int e=10+20*10+20

        根据运算的优先级，要在宏定义的a+b外加上()

        宏函数对参数没有数据类型要求（区别与一般函数）

宏函数

#define ADD(a,b)  (a+b)   (要尽量加上括号，防止语法错误，先后循序不一致。)

预处理阶段工作：①将头文件展开直接放置到源文件中

                    ②宏替换

                    ③条件编译

注意：宏替换只是简单得字符串替换，且可以传递参数。

例如，#define N(n) n*10

   int b = N(a);  // 首先n替换成a，然后a*10。

易错：#define ADD(a,b) a+b

  int c = ADD(a,b) * ADD(a,b);  

/* 经过简单的替换会得到 a+b*a+b，这显示不是我们想要的结果，因此加上括号保证优先级不会出错。*/

正确写法：#define ADD(a,b) (a+b) 这样变换后会成 (a+b)*(a+b)

一般写法：

int add(int a,int b)

{ return a+b;   }

int c = a+b;

那么宏定义写法的优势在哪：

一般写法：参数ab 必须是一种类型的变量，要么整形 int，要么浮点型 float,

字符串不这么写（详见C语言入门第六章6-8 ）

宏定义：参数ab 可以是任意，因为在宏里面所有参数都会被单成字符串来处理，

    只要修改 int c 前面的 int 就行

终于看懂了

#define M int main( ，这句话的意思是用 M 代替 "int main( "这一串字符，所以后面的 M) 就相当于 int main(）。

宏定义定义的计算，只是字符串，计算要等到函数调用时执行，所以定义时注意加（），保证优先级。

宏定义的函数没有数据类型的限制。

预处理阶段工作：①将头文件展开直接放置到源文件中

                           ②宏替换

                           ③条件编译

注意：宏替换只是简单得字符串替换，且可以传递参数。

例如，#define N(n) n*10

           int b = N(a);  // 首先n替换成a，然后a*10。

易错：#define ADD(a,b) a+b

          int c = ADD(a,b) * ADD(a,b);  

/* 经过简单的替换会得到a+b*a+b，这显示不是我们想要的结果，因此加上括号保证优先级不会出错。*/

            #define ADD(a,b) (a+b) 

000000000000000000002.3

#define N(n) n*10

int b=N(a);   //int b=a*10;

#define ADD(a,b) a+b

int b=ADD(a,b);   //int b=a+b;

int e=ADD(a,b)*ADD(a,b)//预处理int e=a+b*a+b->执行

#define ADD(a,b) （a+b）不要求类型

#define N(n) n*9
//则
int a = 10;
int b = N(a);  // int b = a*9

#define ADD(a,b) a+b // 加括号保险，故
#define ADD(a,b) (a+b)
//
int x;
int y;
int b = ADD(x,y); // x+y

预处理对宏只会做字符串替换，不是语法，运算

宏也可以传递参数
e.g #define N(n) n*10
int a=20;
int b= N(a);//
#define ADD(a,b) (a+b) int ADD(a,b); 
优势：不需要定义输入参数好返回值的类型
Plus: 预处理中还有条件编译的功能。

宏还可以传递参数

#define N(n) n*10

main函数中：int b=N(5);   即是int b=5*10;

#define add(a,b) a+b
main函数中：int x=add(20,30) //x=20+30=50
  int x=add(20,30)*add(20,30)  //x=20+30*20+30=650而非2500
  也就是说，宏替换只是替换，并不能运算
  所以最好加（），即#define add(a,b) （a+b）

宏的优势：可以不考虑参数类型：

int add(int a,int b){return a+b;} 对比：

#define add(a,b) （a+b）

宏声明：#define 替代的字符 被替换的数据

预处理之宏定义

预处理只typedef

预处理阶段不会进行运算，宏替换只是单纯的字符串替换