【C语言进阶剖析】21、宏定义与使用分析

C 语言中的宏定义

• #define 是预处理器处理的单元实体之一
• #define 定义的宏可以出现在程序的任意位置
• #define 定义之后的代码都可以使用这个宏

1 定义宏常量

• #define 定义的宏常量可以直接使用
• #define 定义的宏常量本质为字面量

下面定义的宏正确吗？

代码如下：

#define ERROR -1
#define PATH1 "D:\test\test.c" 
#define PATH2 D:\test\test.c
#define PATH3 D:\test\
test.c
int main()
{
    int err = ERROR;
    char* p1 = PATH1;
    char* p2 = PATH2;
    char* p3 = PATH3;
}

先进行预编译

$ gcc -E 21-1.c -o 21-1.i

预编译通过，打开 21-1.i 文件，如下所示：

# 1 "21-1.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "21-1.c"





int main()
{
    int err = -1;
    char* p1 = "D:\test\test.c";
    char* p2 = D:\test\test.c;
    char* p3 = D:\testtest.c;
}

宏定义被直接文本替换，我们定义的 #define 消失了，可以看出，p2，p3 显然指向的字符串不符合 C 语言的语法结构，是错误的，预处理只是进行文本替换，不负责类型检查，真正查找错误还靠编译阶段。

小贴士：宏定义不占内存空间，因为宏在预处理阶段就会被替换掉，到了编译的阶段是没有宏存在的，自然到不了可执行文件中，所以它不占内存空间。

2 宏定义表达式

• #define 表达式的使用类似函数调用
• #define 表达式可以比函数更强大，但是比函数更容易出错

为什么说宏很强大，宏可以做很多函数做不到的事，比如求解一个数组的长度；得出当前文件名，当前行号；将参数类型作为参数传入等等，这些函数都办不到，后面我们一一说明

下面的宏表达式定义正确吗？

// 21-2.c
#include<stdio.h>
#define _SUM_(a, b) (a) + (b)
#define _MIN_(a, b) ((a) < (b) ? (a) : (b))
#define _DIM_(a) sizeof(a)/sizeof(*a)
int main()
{
    int a = 1;
    int b = 2;
    int c[4] = {0};
    int s1 = _SUM_(a, b);
    int s2 = _SUM_(a, b) * _SUM_(a, b);
    int m = _MIN_(a++, b);
    int d = _DIM_(c);
    printf("s1 = %d\n", s1);
    printf("s2 = %d\n", s2);
    printf("m = %d\n", m);
    printf("d = %d\n", d);
    return 0;
}

先单步编译，只进行预处理，编译通过；在进行编译，编译也通过，运行，结果如下：

$ gcc -E 21-2.c -o 21-2.i
$ gcc 21-2.c -o 21-2
$ ./21-2
s1 = 3
s2 = 5
m = 2
d = 4

上面的代码可以看出，s2 是求 a 和 b 和的平方，结果是 5；m 是 a++ 和 b 的最小值，结果为 2，这和我们预想的结果不太对，为什么会出现这种情况呢，我们来看看预处理之后的文件（这里为了省略不必要的信息，注释了 #include<stdio.h> 再执行的预处理）

# 1 "21-2.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "21-2.c"





int main()
{
    int a = 1;
    int b = 2;
    int c[4] = {0};
    int s1 = (a) + (b);
    int s2 = (a) + (b) * (a) + (b);
    int m = ((a++) < (b) ? (a++) : (b));
    int d = sizeof(c)/sizeof(*c);
    printf("s1 = %d\n", s1);
    printf("s2 = %d\n", s2);
    printf("m = %d\n", m);
    printf("d = %d\n", d);
    return 0;
}

可以看到，

• s2 = (a) + (b) * (a) + (b) = 1 + 2 * 1 + 2 = 5
• m = ((a++) < (b) ? (a++) : (b))，执行 (a++) < (b) 结果为真，选择(a++) ，此时 a 的值为 2，所以结果为 2
• 使用宏可以求出数组长度，这在 c 语言中用函数是一定办不到的。

上面我们看到了宏表达式的副作用，在使用时一定要小心。

3 宏表达式与函数表达式的对比

• 宏表达式被预处理器处理，编译器不知道宏表达式的存在
• 宏表达式用 “实参” 完全替代形参，不进行任何运算（完全是文本替换）
• 宏表达式没有任何的 “调用” 开销
• 宏表达式中不能出现递归定义

比如下面的表达式就是不正确的，宏不能递归定义

3 宏有作用域吗？

有个有趣的问题：宏定义的常量或表达式是否有作用于限制？

看下面的程序合法吗？在函数 def() 中定义了宏，能在函数 area() 中使用吗？

// 21-3.c
#include<stdio.h>
void def()
{
    #define PI 3.1415926
    #define AREA(r) r * r *PI
}
double area(double r)
{
    return AREA(r);
}
int main()
{
    double r = area(5);
    printf("PI = %f\n", PI);
    printf("d = 5; a = %f\n", r);
    return 0;
}

上面的程序编译运行通过，结果如下：

为什么在函数 def() 中定义的宏能在函数 area() 中使用吗？

#define 定义之后的代码都可以使用这个宏，C 语言中作用域的概念的是针对变量和函数的，不针对宏，因为宏被预处理器处理，编译器根本就不知道宏的存在，所以没法将作用域的概念加到宏上面。

我们再来看一下单步编译的结果

$ gcc -E 21-3.c -o 21-3.i

# 1 "21-3.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "21-3.c"


void def()
{


}
double area(double r)
{
    return r * r *3.1415926;
}
int main()
{
    double r = area(5);
    printf("PI = %f\n", 3.1415926);
    printf("d = 5; a = %f\n", r);
    return 0;
}

4 强大的内置宏

下面我们来看看 C 语言中强大的内置宏，可以查看被编译的文件名，当前行号，被编译的日期等等。

宏	含义	实例
__FILE__	被编译的文件名	file.c
__LINE__	当前行号	25
__DATE__	编译时的日期	Nov 18 2019
__TIME__	编译时的时间	21：01：01
__STDC__	编译器是否遵循标准 C 规范	1

下面再来看一个示例：宏使用的综合示例

// 21-4.c
#include<stdio.h>
#include<malloc.h>

#define MALLOC(type, x) (type*)malloc(sizeof(type)*x)
#define FREE(p) (free(p), p = NULL)				// 逗号表达式
#define LOG(s) printf("[%s]{%s:%d} %s \n", __DATE__, __FILE__, __LINE__, s)

#define FOREACH(i, m) for(i = 0; i < m; i++)
#define BEGIN {
#define END   }

int main()
{
    int x = 0;
    int* p = MALLOC(int, 5);
    LOG("Begin to run main code...");
    FOREACH(x, 5)
    BEGIN
        p[x] = x;
    END
    FOREACH(x, 5)
    BEGIN
        printf("%d\n", p[x]);
    END
    FREE(p);
    LOG("End");
    return 0;
}

• MALLOC 的作用是在堆空间中申请一个数组，需要注意的是，这里可以将参数类型作为自变量传递给宏
• FREE 是用来释放数组的。通过这个宏还可以在释放空间的同时将指针置为空
• FOREACH 宏也是宏比函数强大的地方，在函数中没有办法实现这个概念
• 主函数先申请一个数组，再将数组中的元素赋值，最后将数组元素打印出来

5 小结

• 预处理器直接对宏进行文本替换，参数不会进行求值、运算
• 预处理器不会对宏定义进行语法检查，语法错误只能被编译器检测
• 宏的效率高于函数调用，也会带来一定的副作用