05.宏处理

约 3611 字大约 12 分钟

宏处理C个人随笔

2021-03-26

一、宏定义与使用分析

1、C语言中的宏定义

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

2、定义宏常量

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

在预编译阶段（预编译 - 预处理，程序不会报错，因为预编译器不会对语法进行检测。

实际不难发现，只有前两个是对的。

3、宏定义表达式

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

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

#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);               // 1 + 2                3
    int s2 = _SUM_(a, b) * _SUM_(a, b); // 1 + 2 * 1 + 2        5
    int m = _MIN_(a++, b);              // 1 < 2 ? 2 : 2        2
    int d = _DIM_(c);                   // 16 / 4               4
 
    printf("s1 = %d\n", s1);
    printf("s2 = %d\n", s2);
    printf("m  = %d\n", m);
    printf("d  = %d\n", d);
 
    return 0;
}

4、宏表达式与函数的对比

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

5、宏定义的常量或表达式没有作用域限制

下面程序合法吗？

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

6、强大的内置宏

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

7、小结

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

二、条件编译使用分析

1、基本概念

条件编译是预编译指示命令，用于控制是否编译某段代码

#include <stdio.h>
 
#define C 1
 
int main()
{
    const char* s;
 
#if( C == 1 )
    s = "This is first printf...\n";
#else
    s = "This is second printf...\n";
#endif
 
    printf("%s", s);
 
    return 0;
}

2、条件编译的本质

预编译器根据条件编译指令有选择的删除代码
编译器不知道代码分支的存在
if...else...语句在运行期进行分支判断
条件编译指令在预编译期进行分支判断
可以通过命令行定义宏
gcc -Dmacro=value file.c 或 gcc -Dmacro file.c

#include <stdio.h>
 
int main()
{
    const char* s;
 
    #ifdef C
        s = "This is first printf...\n";
    #else
        s = "This is second printf...\n";
    #endif
 
    printf("%s", s);
    
    return 0;
}

3、#include的本质

#include的本质是将已经存在的文件内容嵌入到当前文件中
#include的间接包含同样会产生嵌入文件内容的操作
条件编译可以解决头文件重复包含的编译错误（间接包含同一个头文件会产生编译错误）

#ifndef _HEADER_FILE_H_
#define _HEADER_FILE_H_
 
// source code
 
#endif

4、条件编译的意义

条件编译使得我们可以按不同的条件编译不同的代码段，因而可以产生不同的目标代码
#if...#else...#endif被预编译器处理，而if...else...语句被编译器处理，必然被编译进目标代码
实际工程中条件编译主要用于一下两种情况︰

不同的产品线共用一份代码；区分编译产品的调试版和发布版

#include <stdio.h>
#include "product.h"
 
#if DEBUG
#define LOG(s) printf("[%s:%d] %s\n", __FILE__, __LINE__, s)
#else
#define LOG(s) NULL
#endif
 
#if HIGH
void f()
{
    printf("This is the high level product!\n");
}
#else
void f()
{
}
#endif
 
int main()
{
    LOG("Enter main() ...");
 
    f();
 
    printf("1. Query Information.\n");
    printf("2. Record Information.\n");
    printf("3. Delete Information.\n");
 
#if HIGH
    printf("4. High Level Query.\n");
    printf("5. Mannul Service.\n");
    printf("6. Exit.\n");
#else
    printf("4. Exit.\n");
#endif
 
    LOG("Exit main() ...");
 
    return 0;
}

#define DEBUG 1
#define HIGH  1

5、小结

通过编译器命令行能够定义预处理器使用的宏
条件编译可以避免重复包含头同一个头文件
条件编译是在工程开发中可以区别不同产品线的代码
条件编译可以定义产品的发布版和调试版

三、#error 和 #line 使用分析

1、#error的用法

#error用于生成一个编译错误消息
用法

#error message
message不需要用双引号包围

#error编译指示字用于自定义程序员特有的编译错误消息
类似的，#warning用于生成编译警告。

#error是—种预编译器指示字
#error可用于提示编译条件是否满足

#ifndef__cplusplus
   #error This file should be processed with C++ compiler.
#endif

#include <stdio.h>
 
#ifndef __cplusplus
    #error This file should be processed with C++ compiler.
#endif
 
class CppClass
{
private:
    int m_value;
public:
    CppClass()
    {
        
    }
    
    ~CppClass()
    {
    }
};
 
int main()
{
    return 0;
}

编译过程中的任意错误信息意味着无法生成最终的可执行程序。

#include <stdio.h>
 
void f()
{
#if ( PRODUCT == 1 )
    printf("This is a low level product!\n");
#elif ( PRODUCT == 2 )
    printf("This is a middle level product!\n");
#elif ( PRODUCT == 3 )
    printf("This is a high level product!\n");
#else
    #error The “PRODUCT” is NOT defined！ // 预防未宏定义PRODUCT，而程序依然可以编译过
#endif
}
 
int main()
{
    f();
 
    printf("1. Query Information.\n");
    printf("2. Record Information.\n");
    printf("3. Delete Information.\n");
 
#if ( PRODUCT == 1 )
    printf("4. Exit.\n");
#elif ( PRODUCT == 2 )
    printf("4. High Level Query.\n");
    printf("5. Exit.\n");
#elif ( PRODUCT == 3 )
    printf("4. High Level Query.\n");
    printf("5. Mannul Service.\n");
    printf("6. Exit.\n");
#else
    #error The “PRODUCT” is NOT defined！// 预防未宏定义PRODUCT，而程序依然可以编译过
#endif
 
    return 0;
}

2、#line的用法

#line 用于强制指定新的行号和编译文件名，并对源程序的代码重新编号
用法

#line number filename
filename可省略

#line编译指示字的本质是重定义_LINE_和_FILE_

以前常用，现在不常用了：
以前多个程序员，分别写程序，最后合在一起，程序出问题后，利用#line定位是谁出在哪一行的问题

#include <stdio.h>
 
// The code section is written by A.
// Begin
#line 1 "a.c"
 
// End
 
// The code section is written by B.
// Begin
#line 1 "b.c"
 
// End
 
// The code section is written by Delphi.
// Begin
#line 1 "Joker.c"
 
 
int main()
{
    printf("%s : %d\n", __FILE__, __LINE__);
 
    printf("%s : %d\n", __FILE__, __LINE__);
 
    return 0;
}
 
// End

3、小结

#error用于自定义一条编译错误信息
#warning用于自定义一条编译警告信息
#error和#warning常应用于条件编译的情形
#line用于强制指定新的行号和编译文件名

四、#pragma 使用分析

1、#pragma简介

#pragma用于指示编译器完成一些特定的动作；
#pragma所定义的很多指示字是编译器特有的；
#pragma在不同的编译器间是不可移植的；
预处理器将忽略它不认识的#pragma指令
不同的编译器可能以不同的方式解释同一条#pragma指令
一般用法：
#pragma parameter
注：不同的parameter参数语法和意义各不相同

2、#pragma message

message参数在大多数的编译器中都有相似的实现；
message参数在编译时输出消息到编译输出窗口中；
message用于条件编译中可提示代码的版本信息；

#if defined(ANDROID20)
    #pragma message("Compile Android SDK 2.0...")
    #define VERSION "Android 2.0 "
#endif

与#error和#warning 不同，#pragma message仅仅代表一条编译消息，不代表程序错误。

示例

#include <stdio.h>
 
#define ANDROID20 10
 
#if defined(ANDROID20)
    #pragma message("Compile Android SDK 2.0...")
    #define VERSION "Android 2.0"
#elif defined(ANDROID23)
    #pragma message("Compile Android SDK 2.3...")
    #define VERSION "Android 2.3"
#elif defined(ANDROID40)
    #pragma message("Compile Android SDK 4.0...")
    #define VERSION "Android 4.0"
#else
    #error Compile Version is not provided!
#endif
 
int main()
{
    printf("%s\n", VERSION);
 
    return 0;
}

GCC：回把#pragma message打印出来。

VC和BCC：只打印消息。

3、#pragma once

#pragma once用于保证头文件只被编译一次
#pragma once是编译器相关的，不一定被支持
以下两者的区别为？

#ifndef 其实包含了多次，预处理器还是处理了多次，所以效率低于#pragma once。

VC和GCC：正常。
BCC：不支持。

想要保证代码的一致性和效率

#ifndef _GLOBAL_H_
#define _GLOBAL_H_
 
#pragma once
 
// code
 
#endif

4、#pragma pack

什么是内存对齐?
不同类型的数据在内存中按照一定的规则排列
而不一定是顺序的一个接一个的排列

以下两个结构体各占多大内存？

struct Test1
{
    char  c1;
    short s;
    char  c2;
    int   i; 
};
 
struct Test2
{
    char  c1;
    char  c2;
    short s;
    int   i;
};

写一段代码运行一下：

这是为什么呢？

为什么需要内存对齐?

CPU对内存的读取不是连续的，而是分成块读取的，块的大小只能是1、2、4、8、16...字节；
当读取操作的数据未对齐，则需要两次总线周期来访问内存，因此性能会大打折扣；
某些硬件平台只能从规定的相对地址处读取特定类型的数据，否则产生硬件异常；

#pragma pack 用于指定内存对齐方式
#pragma pack能够改变编译器的默认对齐方式

struct占用的内存大小(重要)

第一个成员起始于0偏移处
每个成员按其类型大小和pack参数中较小的一个进行对齐
偏移地址必须能被对齐参数整除
结构体成员的大小取其内部长度最大的数据成员作为其大小（注意这里只是在对比pack时使用，并不表示真实的大小）
结构体总长度必须为所有对齐参数的整数倍
编译器在默认情况下按照4字节对齐。

编译器在默认情况下按照4字节对齐。

#include <stdio.h>
 
#pragma pack(4)
struct Test1
{
    char  c1;
    short s;
    char  c2;
    int   i;
};
#pragma pack()
 
#pragma pack(4)
struct Test2
{
    char  c1;
    char  c2;
    short s;
    int   i;
};
#pragma pack()
 
int main()
{
    printf("sizeof(Test1) = %d\n", sizeof(struct Test1));
    printf("sizeof(Test2) = %d\n", sizeof(struct Test2));
 
    return 0;
}

具体计算下，如何得出的12和8？

#pragma pack(4)
struct Test1        
{            		//   对齐参数  	 偏移地址    大小
    char  c1;	    //      1           0         1
    short s;		//      2		    2		  2
    char  c2;	    //      1		    4		  1
    int   i;		//      4		    8		  4
};
#pragma pack()
 
#pragma pack(4)
struct Test2
{            		//   对齐参数  	    偏移地址		 大小
    char  c1;	    //      1              0          1
    char  c2;	    //      1		       1		  1
    short s;		//      2		       2		  2
    int   i;		//      4		       4		  4
};
#pragma pack()

再来一题：以下各结构体内存是多少？（微软的面试题）
#include <stdio.h>
 
#pragma pack(8)
 
struct S1
{
    short a;
    long b;
};
 
struct S2
{
    char c;
    struct S1 d;
    double e;
};
 
#pragma pack()
 
int main()
{
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
 
    return 0;
}
struct S1
{ // 对齐参数偏移地址大小
short a; // 2 0 2
long b; // 4 4 4
};
struct S2
{ // 对齐参数偏移地址大小
char c; // 1 0 1
struct S1 d;// 4 4 8(这里是原结构体大小)
double e; // 8 16 8
};

GCC编译器暂时不支持8字节对齐。

5、小结

#pragma用于指示编译器完成一些特定的动作
#pragma所定义的很多指示字是编译器特有的
#pragma message用于自定义编译消息
#pragma once用于保证头文件只被编译一次
#pragma pack用于指定内存对齐方式

五、# 和 ## 操作符使用分析

1、#运算符

#运算符用于在预处理期将宏参数转换为字符串
#的转换作用是在预处理期完成的，因此只在宏定义中有效
编译器不知道#的转换作用
用法
#运算符的基本用法

#include <stdio.h>
 
#define STRING(x) #x
 
int main()
{
 
    printf("%s\n", STRING(Hello world!));
    printf("%s\n", STRING(100));
    printf("%s\n", STRING(while));
    printf("%s\n", STRING(return));
 
    return 0;
}

预编译器阶段

#运算符的妙用（重要）打印想要调用函数的函数名，并执行函数

#include <stdio.h>
 
#define CALL(f, p) (printf("Call function %s\n", #f), f(p))// 打印想要调用函数的函数名，并执行函数
   
int square(int n)
{
    return n * n;
}
 
int func(int x)
{
    return x;
}
 
int main()
{
    int result = 0;
    
    result = CALL(square, 4);
    
    printf("result = %d\n", result);
    
    result = CALL(func, 10);
    
    printf("result = %d\n", result);
 
    return 0;
}

预编译器阶段

2、##运算符

##运算符用于在预处理期粘连两个标识符
##的连接作用是在预处理期完成的，因此只在宏定义中有效
编译器不知道##的连接作用
用法
##运算符的基本用法（智能定义变量名）

#include <stdio.h>
 
#define NAME(n) name##n
 
int main()
{
    
    int NAME(1);
    int NAME(2);
    
    NAME(1) = 1;
    NAME(2) = 2;
    
    printf("%d\n", NAME(1));
    printf("%d\n", NAME(2));
 
    return 0;
}

预编译器阶段

运算符的工程应用

#include <stdio.h>
 
#define STRUCT(type) typedef struct _tag_##type type;\
                     struct _tag_##type
 
STRUCT(Student)
{
    char* name;
    int id;
};
 
int main()
{
    
    Student s1;
    Student s2;
    
    s1.name = "s1";
    s1.id = 0;
    
    s2.name = "s2";
    s2.id = 1;
    
    printf("s1.name = %s\n", s1.name);
    printf("s1.id = %d\n", s1.id);
    printf("s2.name = %s\n", s2.name);
    printf("s2.id = %d\n", s2.id);
 
    return 0;
}

预编译器阶段

3、小结

#运算符用于在预处理期将宏参数转换为字符串
##运算符用于在预处理期粘连两个标识符
编译器不知道#和##运算符的存在
#和##运算符只在宏定义中有效

版权所有

版权归属：sumjess

许可证：署名 4.0 国际 (CC-BY-4.0)

C基础精炼

深入浅出C语言

C陷阱与缺陷

C查缺补漏

NCRE-C-2018年

CPrimerPlus

05.宏处理

一、宏定义与使用分析

1、C语言中的宏定义

2、定义宏常量

3、宏定义表达式

4、宏表达式与函数的对比

5、宏定义的常量或表达式没有作用域限制

6、强大的内置宏

7、小结

二、条件编译使用分析

1、基本概念

2、条件编译的本质

3、#include的本质

4、条件编译的意义

5、小结

三、#error 和 #line 使用分析

1、#error的用法

2、#line的用法

3、小结

四、#pragma 使用分析

1、#pragma简介

2、#pragma message

3、#pragma once

4、#pragma pack

5、小结

五、# 和 ## 操作符使用分析

1、#运算符

2、##运算符

运算符的工程应用

3、小结

版权所有