#define定义标识符详解

0.预定义符号

在讲解#define之前先给大家介绍几个预定义符号

__FILE__      //进行编译的源文件
__LINE__     //文件当前的行号
__DATE__    //文件被编译的日期
__TIME__    //文件被编译的时间
__STDC__    //如果编译器遵循ANSI C（标准C），其值为1，否则未定义

这些预定义符号都是编译器自带的，可以直接使用，我们可以用printf函数去打印。

#include "stdio.h"
 int main()
 {
     printf("%s\n",__FILE__);
     printf("%d\n",__LINE__);
     printf("%s\n",__DATE__);
     printf("%s\n",__TIME__);
     printf("%d\n",__STDC__);
     return 0;
 }

1. 语法分析

                                #define     name     stuff

name代表的是stuff新的名字

stuff代表的是实现的内容

name的名字最好要全大写！！！！！

就比如你总会用到一个数字，但是你还需要将它换值，如果我们不用#define来，我们就需要每次都写这个值，改值的时候也要一次次去修改，这给我们带来了很多的麻烦，所以这个时候我们可以使用#define来定义这个数值，给他取个名字，代表这个数值，改值的时候就可以直接在#define这里修改，改一次就行，大大提高了写代码的效率。

记住这一点，#define可以将name替换成stuff。一定是替换，将name换成stuff。

比如：

代码1
#include "stdio.h"
 int main()
 {
     int a = 10;
     int b = 20;
     int c = 30;
     if(a < 25)
         printf("aYES\n");
     if(b < 25)
         printf("bYES\n");
     if(c < 25)
         printf("cYES\n");
     return 0;
 }

代码2
#define n 25
 int main()
 {
     int a = 10;
     int b = 20;
     int c = 30;
     if(a < n)
         printf("aYES\n");
     if(b < n)
         printf("bYES\n");
     if(c < n)
         printf("cYES\n");
     return 0;
 }

代码1如果修改25需要修改3次，但是代码2通过#define定义后，只需要修改n后面的值就行，这就大大提高了修改的效率。

1.1 举例分析

1.1.1 代码1

#define MAX 100
 int main()
 {
     int a = MAX;
     int a = 100;
     return 0;
 }

我们来看第一个，我们用#define定义了MAX的数值是100，所以在主函数使用的时候

int a = MAX;就相当于 int a = 100; 也就是把MAX替换成了100

1.1.2 代码2

#include "stdio.h"
#define sz sizeof
 int main()
 {
     int a = sz(int);
     int b = sizeof (int);
     printf("%d %d",a,b);
     return 0;
 }

第二个代码，是用#define来定义一个sz，代表sizeof关键字，所以在使用过程中，sz(int)就可以替换成sizeof(int)

1.1.3 代码3

代码1
#include "stdio.h"
#define do_forever for(;;)
 int main()
 {
     do_forever
     {
         printf("1");
     }
     return 0;
 }
代码2

#include "stdio.h"
 int main()
 {
     for(;;)
     {
         printf("1");
     }
     return 0;
 }

这两个代码是等效的，代码1我们用#define定义了一个死循环，当编译的时候do_forever就会被替换成for(;;)。

所以#define可以定义任何东西，但是在使用时候会被自动替换成定义后面的东西。

1.1.4代码4

代码1
#include "stdio.h"
#define PRINT printf("file:%s\nline:%d\ndate:%s\ntime:%s\n",__FILE__,__LINE__,__DATE__,__TIME__)
 int main()
 {
     PRINT;
     return 0;
 }
代码2
#include "stdio.h"
#define PRINT printf("file:%s\n\
                     line:%d\n\
                     date:%s\n\
                     time:%s\n",__FILE__,__LINE__,__DATE__,__TIME__)
 int main()
 {
     PRINT;
     return 0;
 }
代码3
#include "stdio.h"
 int main()
 {
     printf("file:%s\nline:%d\ndate:%s\ntime:%s\n",__FILE__,__LINE__,__DATE__,__TIME__);
     return 0;
 }

首先看代码1，我们是#define定义了一个PRINT，它是后面的一大串打印内容的，大家是不是也会觉得很长。

所以我们优化看一下代码2，我们将其回车分成了4行，但是这里要记住，一定要在我们敲回车的地方➕一个‘ \ ’，告诉编译器这还是一个整体的内容，也就是将我们敲的回车给转义了。如果不加这个’ \ ‘，整体代码就会出问题。

1.2 #define末尾是否应该添加' ; '

答案是最好不要加分号，那又是为什么呢？

我们知道#define是替换，比如上面我们是将MAX直接替换成了100、sz直接替换成了sizeof、do_forever直接替换成了for(;;)等等。

那我们如果加上了分号' ; '之后呢？

代码1
#define MAX 100;
 int main()
 {
     int a = MAX;
     return 0;
 }
代码2
#define MAX 100;
 int main()
 {
     int a = 100;;
     return 0;
 }
代码3
#define MAX 100;
 int main()
 {
     int a = MAX
     return 0;
 }

首先代码1和代码2是等效的，我们可以看到加了分号之后，MAX是被替换成了100；，这里就有2个分号了，肯定是错误的。

那怎么去修改呢？

我们可以像代码3一样，在主函数那里也就是语句结尾，不加分号，等替换之后就有分号了，但是这跟咱们的书写习惯大大不同，所以最好不要加分号！

2. #define定义宏

2.1 语法分析

         #define name( parament-list ) stuff

1.#define定义宏和函数很相似
2.name相当于函数名
3.parament-list 就相当于函数参数
4.stuff就是相当于这个函数的功能

注意⚠️⚠️：这里的左括号一定要跟name紧挨着
                       否则会name就会被替换成( parament-list ) stuff

比如：

代码1

#define MAX(x,y) (x) > (y) ? (x) : (y) 
int main()
{
    MAX(2,3);
    MAX(2,3);相当于：(2) > (3) ? (2) : (3);
}

代码2

#define MAX (x,y) (x) > (y) ? (x) : (y)
int main()
{
    MAX(2,3);
    MAX相当于：(x,y) (x) > (y) ? (x) : (y)
}

代码1是左括号紧挨着name的，那我们就可以用MAX(x,y)完成我们想要实现的功能。

代码2是没有紧挨着的，这时候会出现错误，因为此时是MAX相当于(x,y) (x) > (y) ? (x) : (y)
这时候MAX啥也不是，是个错误。

所以左括号必须跟name紧挨着！

总而言之还是要记住#define是替换的作用。

2.2代码举例

2.2.1 代码1

#define Square(x) x * x

我们定义了一个Square(x)，它的作用是求一个数的平方，参数是x

Square(5);

所以我们在引用的时候，给括号里数字5

5 * 5

就相当于5*5，可以求出来这个数的平方。

但是如果是这样的代码，结果又会是多少呢？

#include "stdio.h"
#define Square(x) x * x
int main()
{
    int a = 5;
    printf("%d\n" ,Square( a + 1) );
    return 0;
}

正确答案是11
我相信很多人都会得出36，但是我们一直在说#define是替换，所以上面代码又可以变成如下

#include "stdio.h"
#define Square(x) x * x
int main()
{
    int a = 5;
    printf("%d\n" ,a + 1 * a + 1 );
    return 0;
}

对吧，这时候Square(a+1)会被替换成 a+1*a+1，优先乘法运算，结果是11

也就是说我们#define定义的，真的就是替换，你给什么替换什么，不会加括号，所以为了算出正确结果，一定要加括号，在#define宏定义时候，要多加括号。

正确代码：

#include "stdio.h"
#define Square(x) (x) * (x)
int main()
{
    int a = 5;
    printf("%d\n" ,Square( a + 1) );
    return 0;
}

2.2.2 代码2

#define DOUBLE(x) (x) + (x)

我们看这个#define定义的DOUBLE(x) 是求一个数的二倍，在这里我们给x加了括号避免了之前的错误，那下面代码输出的是什么呢？

int a = 5;
printf("%d\n" ,10 * DOUBLE(a));

我相信大多数人现在肯定是算出正确结果了，因为之前吃的亏
答案是55

和我们预想结果不一样呀，我们预想的是100，为什么不一样呢？

int a = 5;
printf("%d\n" ,10 * 5 + 5);

实际上，DOUBLE(a)是被替换成了5 + 5，但是前面有个10，还是乘法，就变成了10*5+5.那如何解决这个问题呢？还是加括号，代码如下

#define DOUBLE(x) ((x) + (x))

我们只需要整体加个括号就可以完美解决问题啦！

总结：

在#define定义宏的时候也就是类似函数，一定要多加括号，避免错误。

3.#define的替换规则

3.1 规则1

  规则1 : 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。

               如果是，它们首先被替换。

这是什么意思呢？我们拿代码举例：

#include "stdio.h"
#define n 100
#define MAX(x,y) ((x) > (y) ? (x) : (y))
 int main()
 {
     int a = 20;
     int c = MAX(a,n);
     printf("max是%d\n",c);
     return 0;
 }

在MAX(x,y)里，主函数传的参数里分别是a，n

a是我们定义的局部变量，而n是#define定义的符号，所以根据规则，要首先被替换。

就变成了这样：

int c = MAX(a,100);

n被替换成了100，之后再去替换#define定义的宏

int c = ((a) > (100) ? (a) : (100));

3.2 规则2

规则2:

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

述处理过程。

这一点没什么说的，反正就是你在#define定义的时候一定要看先发生的是谁就行。

4.‘#’和‘##’的作用

4.1‘#’作用

我们先看这样一段代码

char* p = "hello ""bit\n";
printf("hello"" bit\n");
printf("%s", p);

此时输出的是

我们可以看到两个输出的都是一样的，所以我们发现字符串它是有自动连接的特点，也就是说我打印完“hello ”这个字符串，但是发现后面还有，那就接着打印。

我们明确了这个之后，思考这样一个问题 ，如何把参数插入到字符串中？

看这样一段代码：

#include "stdio.h"
#define PRINT(n) printf("n的值是%d\n", n)
int main()
{
	int a = 20;
    PRINT(a);
	return 0;
}

我们用PRINT想打印传入的参数的值，但是这么打印得到的结果是

首先第一点我们是要求a的值，我希望打印出来可以告诉我a的值是20，那这个时候‘#’就派上用场了。

#include "stdio.h"
#define PRINT(n) printf(#n"的值是%d\n", n)
int main()
{
	int a = 20;
    PRINT(a);
	return 0;
}

我们首先要知道printf函数是可以打印字符串的，字符串有自动连接的特点
我们想把a打印到屏幕上，就需要在n的前面加上‘#’这个符号，#n会被替换成"a"

#define PRINT(n) printf(#n"的值是%d\n", n)

PRINT(a);
替换成
printf("a""的值是%d\n", a);

这样我们就打印出来想要的结果了

我们解决了名字的问题，但是如果输入个浮点数呢？别的类型呢？又该怎么办呢？

#include "stdio.h"
#define PRINT(n) printf(#n"的值是%d\n", n)
int main()
{
	int a = 20;
    PRINT(a);
    float b = 3.14;
    PRINT(b);
	return 0;
}

在这段代码里肯定是输出不来浮点数b的，因为%d被写死了，我们是否可以把打印的格式传参呢？

#include "stdio.h"
#define PRINT(n,format) printf(#n"的值是"format"\n", n)
int main()
{
	int a = 20;
    PRINT(a,"%d");
    float b = 3.14;
    PRINT(b,"%f");
	return 0;
}

我们是传入的字符串，所以在printf里可以直接写format，因为会被替换成

#define PRINT(n,format) printf(#n"的值是"format"\n", n)

 PRINT(a,"%d");
替换
 printf("a""的值是""%d""\n", n);

 PRINT(b,"%f");
替换
 printf("b""的值是""%f""\n", n);

这样就可以打印出来任何数据类型了。

4.2 ##的作用

 ##可以把位于它两边的符号合成一个符号，这个用途不大，但是很新奇。

比如：

#define Cat(x,y) x##y
 int main()
 {
     int helloworld = 100;
     printf("%d\n", Cat(hel,loworld));
     return 0;
 }

大家可以想一想输出的结果是多少？

我们一步一步来，先替换

Cat(hel,loworld)
替换成
hel##loworld

而##还可以连接左右的符号

hel##loworld
变成
helloworld

我们这个程序输出的就是helloworld的值，100.