【C语言进阶深度学习记录】十七宏定义的使用与分析

r囧r小猫 2022-03-17 07:35 371阅读 0赞

> ### 文章目录 ###
> 
>  *   *  1 C语言中的宏定义
>      *   *  1.1 定义宏常量
>          *  1.2 宏定义表达式
>          *  1.3 宏表达式与函数的对比
>          *  1.4 宏表达式的作用域
>      *  2 C语言中的内置宏
>      *  3 宏定义的代码综合示例
>      *  4 总结

## 1 C语言中的宏定义 ##

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

> 因为宏定义是在预处理器处理的，所以如果怀疑是宏定义出错，可以单步编译到预处理阶段，查看预处理后的代码。参考文章：[编译的过程][Link 1]

### 1.1 定义宏常量 ###

*  \#define 定义的宏常量可以直接使用。常量也可以是字符和字符串
 *  \#define 定义的宏常量本质为字面量（字面量到底是什么，存在哪里？后期还会学习记录）
 *  在预处理阶段直接将定义的宏进行文本替换

如下面的代码（先不管这个代码有什么问题）：

*  21-1.c

#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 如下：
 *  21-1.i

# 1 "21-1.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 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;
    }

*  可以看到定义的宏常量，是直接在编译器的预处理阶段被文本替换了。
 *  上述代码是有问题的，如果直接编译的话，会出现编译错误。从替换后的16,17行可以看出错误之处。

### 1.2 宏定义表达式 ###

*  \#define 定义的表达式**类似**函数调用
 *  并且\#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;
    }

*  编译上面的代码结果为：

s1 = 3  
s2 = 5  
m = 2  
d = 4

很明显与我们所期望的结果不一样。实际上还是宏定义表达式没有定义好，在预处理阶段，直接将宏定义表达式替换的原因。

将上述代码的第1、19、20、21、22注释掉，然后使用预处理编译指令进行单步编译上面的代码，gcc -E 21-2.c -o 21-2.i 得到的结果如下：

*  21-2.i

# 1 "21-2.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 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);
    
    
    
    
    
    
        return 0;
    }

*  很明显，宏替换之后，第19行很明显不是我们想要的那样。

### 1.3 宏表达式与函数的对比 ###

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

### 1.4 宏表达式的作用域 ###

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

在回答这个问题之前，先看看下面的代码：

*  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;
    }

*  编译运行上述代码结果如下：

PI = 3.141593  
d = 5; a = 78.539815

*  这说明，上述宏定义是有效的。并没有因为函数的结束而销毁。
 *  其实，因为宏定义在预处理阶段就被处理替换了，所以作用域不会影响宏定义。
 *  只要定义完宏之后，它**后面**的代码就可以使用
 *  作用域是在**编译阶段**针对变量和函数，不影响已经在**预处理阶段**替换了的宏。

## 2 C语言中的内置宏 ##

在C语言中，有很多内置宏，可以供我们使用，这样节省了我们的开发时间。下面罗列一些常用的:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center]

> 注意，上面的宏，都是代表当前编译时的xxx

## 3 宏定义的代码综合示例 ##

可以使用下面的综合例子来说明本文宏的使用：

*  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;
    }

*  编译运行的结果为：

![在这里插入图片描述][20190222234841603.png_pic_center]

*  上述的代码也是比较简单的，但是同时将本片文章的所有内容都囊括在内了，是一个非常不错的例子

## 4 总结 ##

*  预处理器直接对宏进行替换
 *  预处理器不会对宏定义进行语法检查
 *  宏定义时出现的语法错误，只能被编译器检测到
 *  宏定义的效率高于函数调用
 *  宏定义容易出错

[Link 1]: https://blog.csdn.net/qq_37375427/article/details/87815000
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center]: /images/20220317/66afa25fd2214beb98f4a723e4e5afc7.png
[20190222234841603.png_pic_center]: /images/20220317/269bf1006f5d42a4ab72e08027ef2616.png