文章目录

1 C语言中的宏定义

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

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

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语言中，有很多内置宏，可以供我们使用，这样节省了我们的开发时间。下面罗列一些常用的:

注意，上面的宏，都是代表当前编译时的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;
}
  • 编译运行的结果为：

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

4 总结

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