一.#define

1.1#define的使用

1.2在define定义标识符的时候，要不要在最后加上 ;?

二.#define定义宏

2.1好代码的写法:

2.2#define 替换规则

2.3#和##

三.带有副作用的宏参数

四.宏和函数的对比

五.实现offetof

思路解析过程：

代码实现：

六.写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换

思路分析：

代码实现：

一.#define

1.1#define的使用

语法：

#include<stdio.h>
#define MAX 1000

int main()
{
	printf("%d \n", MAX);

	return 0;
}

结果：

格式：

#define MAX 1000
#define reg register          //为 register这个关键字，创建一个简短的名字
#define do_forever for(;;)     //用更形象的符号来替换一种实现
#define CASE break;case        //在写case语句的时候自动把 break写上。

建议#define 定义的名字全大写来区分

举个例子：

#define MAX 1000
#define reg register          //为 register这个关键字，创建一个简短的名字
#define do_forever for(;;)     //用更形象的符号来替换一种实现
#define CASE break;case        //在写case语句的时候自动把 break写上。

1.2在define定义标识符的时候，要不要在最后加上 ;?

建议不用加！！！

例子:
#define MAX 1000;
替换过来就是这样的：

#define的本质是替换！！！

二.#define定义宏

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

2.1好代码的写法:

例子:

这个代码有个问题
#include<stdio.h>
#define SQUARE(x) x * x

int main()
{
	printf("%d \n", SQUARE(5));
	return 0;
}
结果:

结果没有问题呀，那如果是这样的代码呢？
#include<stdio.h>
#define SQUARE(x) x * x

int main()
{
	printf("%d \n", SQUARE(5+1));
	return 0;
}
我们想要的是： 6 * 6 = 36

结果:

为什么他是11，不是36？

因为本质是替换：

5 + 1 * 5 + 1 = 11

优化一下:
#define SQUARE(x) (x) * (x)
结果：

那又如果是：
#define SQUARE(x) (x) + (x)

int main()
{
	int a = 5;
	printf("%d\n", 10 * SQUARE(a));
	return 0;
}
我们想要的： 10 * 10 = 100

但结果是：55

因为替换下来的结果是： 10 * (5) + (5)

最终优化：
#include<stdio.h>
#define SQUARE(x) ((x) + (x))

int main()
{
	int a = 5;
	printf("%d\n", 10 * SQUARE(a));
	return 0;
}
结果：

提示:所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

2.2#define 替换规则

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

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

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

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

注意：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。 2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

2.3#和##

这两个都要配合#define使用

这个稍微的有一点偏题但是，又结合宏可以实现一个功能：

#的作用就是，加了#的变量，变成一个字符串使用：

铺垫：

我们发现C语言字符串有直接拼接的功能

例子:

我们发现这样的代码有点麻烦，那我们能不能写个函数实现一下打印的功能？

发现不同的地方其实就这几个：

而且我们发现函数没法搞,这个时候宏就该上场了：
#include<stdio.h>

#define PRINT(val,format) printf("the value of "#val" is "format"\n",val)
//解析拿a举例：           printf("the value of" "a" " is " "%d" "\n",val );
int main()
{
	int a = 9;
	PRINT(a, "%d");

	float b = 5.5f;
	PRINT(b, "%f");

	char c = 'c';
	PRINT(c, "%c");
	return 0;
}
结果：

## 的作用：

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

例子：
#include <stdio.h>

#define CAT(A,B) A##B
int main()
{
	int ABCDEF = 1000;
	printf("%d\n",CAT(ABC,DEF));

	return 0;
}
结果：

就只是把变量名拼接了起来使用

注：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的

三.带有副作用的宏参数

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

例如：

x+1;//不带副作用
x++;//带有副作用

例子：

#include<stdio.h>
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

int main()
{
	int x = 3;
	int y = 4;
	int z = MAX(x++, y++);
	printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

	return 0;
}

分析:

这样的代码会引起一系列的不良反应

结果：

四.宏和函数的对比

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的一个。

#define MAX(a, b) ((a)>(b)?(a):(b))

那为什么不用函数来完成这个任务？

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。 所以宏比函数在程序的规模和速度方面更胜一筹。

2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。 宏是类型无关的。

宏的缺点：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。

2. 宏是没法调试的。

3. 宏由于类型无关，也就不够严谨。

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。除了非常小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
执行速度	更快	存在函数的调用和返回的额外开销，所以相对慢一些
操作符优先级	宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号。	函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。
带有副作用的参数	参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。	函数参数只在传参的时候求值一次，结果更容易控制。
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用于任何参数类型。	函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是相同的。
调试	宏是不方便调试的	函数是可以逐语句调试的
递归	宏是不能递归的	函数是可以递归的

五.实现offetof

offsetof是计数结构体类型成员在内存上的偏移量，并且他并不是函数，而是由宏实现的，因为他的实参传入了结构体类型，但是函数是不能传入类型的

如果你还不会结构体偏移量可以学习我这一篇文章：https://blog.csdn.net/Lizhihao_/article/details/126903868?spm=1001.2014.3001.5502

演示：

思路解析过程：

代码实现：

我这里并没有去访问0地址，只是拿出来玩了一下，真正拿出的是m_name的地址

结果：

代码：

#include<stdio.h>
#include<stddef.h>

#define OFFSTROF(s_type,m_name)          (size_t)&(((s_type*)0)->m_name)

struct S
{
	char name;
	int age;
	char sz;
};

int main()
{
	printf("%zu\n", OFFSTROF(struct S, name));
	printf("%zu\n", OFFSTROF(struct S, age));
	printf("%zu\n", OFFSTROF(struct S, sz));

	/*printf("%zu\n", offsetof(struct S, name));
	printf("%zu\n", offsetof(struct S, age));
	printf("%zu\n", offsetof(struct S, sz));*/

	return 0;
}

六.写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换

思路分析：

代码实现：

3. 结果：

代码：

#include<stdio.h>

#define SWAP_BIT(n)    n = (((n & 0x55555555) << 1) + ((n & 0xaaaaaaaa)>>1))

int main()
{
	int n = 10;
	//             n = 00000000 00000000 00000000 00001010 
	//要实现的结果:n = 00000000 00000000 00000000 00000101(5)
	SWAP_BIT(n);
	printf("%d\n", n);
	return 0;
}