C语言进阶（五）：宏处理
目录
一、宏定义与使用分析
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、小结
一、宏定义与使用分析
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.cint 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 3int s2 = _SUM_(a, b) * _SUM_(a, b); // 1 + 2 * 1 + 2 5int m = _MIN_(a++, b); // 1 < 2 ? 2 : 2 2int d = _DIM_(c); // 16 / 4 4printf("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)BEGINp[x] = x;ENDFOREACH(x, 5)BEGINprintf("%d\n", p[x]);ENDFREE(p);LOG("End");return 0;
}
7、小结
- 预处理器直接对宏进行文本替换
- 宏使用时的参数不会进行求值和运算
- 预处理器不会对宏定义进行语法检查
- 宏定义时出现的语法错误只能被编译器检测
- 宏定义的效率高于函数调用
- 宏的使用会带来一定的副作用
二、条件编译使用分析
1、基本概念
条件编译是预编译指示命令，用于控制是否编译某段代码
#include <stdio.h>#define C 1int main()
{const char* s;#if( C == 1 )s = "This is first printf...\n";
#elses = "This is second printf...\n";
#endifprintf("%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 Cs = "This is first printf...\n";#elses = "This is second printf...\n";#endifprintf("%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()
{
}
#endifint main()
{LOG("Enter main() ...");f();printf("1. Query Information.\n");printf("2. Record Information.\n");printf("3. Delete Information.\n");#if HIGHprintf("4. High Level Query.\n");printf("5. Mannul Service.\n");printf("6. Exit.\n");
#elseprintf("4. Exit.\n");
#endifLOG("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.
#endifclass 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，而程序依然可以编译过 #endifreturn 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!
#endifint 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#endif4、#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 1short s; // 2 2 2char c2; // 1 4 1int i; // 4 8 4 }; #pragma pack()#pragma pack(4) struct Test2 { // 对齐参数 偏移地址 大小char c1; // 1 0 1char c2; // 1 1 1short s; // 2 2 2int 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) #xint 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##nint 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_##typeSTRUCT(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、小结
- #运算符用于在预处理期将宏参数转换为字符串
##运算符用于在预处理期粘连两个标识符
- 编译器不知道#和##运算符的存在
- #和##运算符只在宏定义中有效
C语言进阶（五）：宏处理相关推荐
- 【C语言进阶】 宏定义实现字符串引用
宏定义实现字符串引用 原理 最简单的引用策略 使用#进行转义 原理 用宏定义实现字符串引用: 这种做法在编译的时候直接给宏名所对应的字符串 分配了一个内存地址空间,可以进行字符串输出.地址打印.指针操 ...
- 【C语言进阶深度学习记录】三十五 程序中的堆、栈以及静态存储区（数据区）
学习交流加 个人qq: 1126137994 个人微信: liu1126137994 学习交流资源分享qq群: 962535112 在我之前学习底层的知识的时候,也写过相关的内容.可以对比的学习:[软 ...
- 【C语言进阶深度学习记录】十七 宏定义的使用与分析
文章目录 1 C语言中的宏定义 1.1 定义宏常量 1.2 宏定义表达式 1.3 宏表达式与函数的对比 1.4 宏表达式的作用域 2 C语言中的内置宏 3 宏定义的代码综合示例 4 总结 1 C语言中 ...
- 【C语言进阶深度学习记录】五 C语言中变量的属性
上一篇文章学习了C语言中的类型转换,点击链接查看:[C语言进阶深度学习记录]四 C语言中的类型转换. 文章目录 1 C语言的变量属性 1.1 auto关键字 1.2 register关键字 1.3 s ...
- C语言进阶深度学习目录表
学习交流加(可免费帮忙下载CSDN资源): 个人微信(进微信群加): LyyCoder 学习交流资源分享qq群1(已满): 962535112 学习交流资源分享qq群2(已满): 780902027 ...
- Python 百天读书笔记 | Python语言进阶 16-20day
Python语言进阶 重要知识点 生成式(推导式)的用法 prices = {'AAPL': 191.88,'GOOG': 1186.96,'IBM': 149.24,'ORCL': 48.44,'A ...
- Day16-20 Python语言进阶
Python语言进阶 重要知识点 生成式(推导式)的用法 prices = {'AAPL': 191.88,'GOOG': 1186.96,'IBM': 149.24,'ORCL': 48.44,'A ...
- C语言 | 进阶之路第一关
目录 前言 - 文章概述 深入剖析数据在内存中的存储 数据的类型 整型在内存中的存储 浮点型在内存中的存储 指针进阶 字符指针 指针数组 数组指针 数组传参和指针传参 函数指针 函数指针数组 指向函数 ...
- 16-20.Python语言进阶
Python语言进阶 重要知识点 生成式(推导式)的用法 prices = {'AAPL': 191.88,'GOOG': 1186.96,'IBM': 149.24,'ORCL': 48.44,'A ...
最新文章
- window resize和scroll事件的基本优化
- cygwin不能执行make
- java中的Sort函数，你值得看
- Naughty Stone Piles（CF-226B）
- 小爱同学与小冰将实现联合进步
- java JDBC操作MySQL数据库
- android.content.res.Resources$NotFoundException: String resource ID #0x0
- 微服务架构学习笔记（一）：重新认识微服务
- navicat 10免费下载及破解
- 总有几位老师让你一生感激不尽----老师侯捷
- 英文字体识别在线识别_如何查找和识别字体
- WAF - SQL注入之绕过云锁 靶场实战
- [微语 20.11.17] 本质
- 服务器UDIMM、LRDIMM、RDIMM的区别
- SSM校园外卖订餐系统
- 第四章第十节数据资产盘点-形成数据资产目录
- java什么是布尔型_Java新职篇：是什么是布尔型?
- wlh机器人_机器人小组活动实施方案
- 英文会议论文出版地信息汇总
- filebeat收集日志到elsticsearch中并使用ingest node的pipeline处理