C语言 详细讲解#pragma的使用方法
时间：2022-07-18 09:34:17 | 栏目：C代码 | 点击：次
一、#pragma 简介
#pragma 用于指示编译器完成一些特定的动作
#pragma 所定义的很多指示字是编译器特有的
#pragma 在不同的编译器间是不可移植的
- 预处理器将忽略它不认识的 #pragma 指令
- 不同的编译器可能以不同的方式解释同一条 #pragma 指令
一般用法：
#pragma parameter
注：不同的 parameter 参数语法和意义各不相同
二、#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 仅仅代表一条编译消息，不代表程序错误。
下面看一个 #pragma message 使用示例：
test.c：
#include <stdio.h>
#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;
}
下面为输出结果：
三、#pragma once
- #pragma once 用于保证头文件只被编译一次
- #pragma once 是编译器相关的，不一定被支持
下面两种方式的区别是：前者是被 C 语言所支持的，并不是只包含一次头文件，而是包含多次，然后通过宏控制是否嵌入到源代码中，也就是说通过宏的方式，可以保证头文件里面的内容只被嵌入一次，但是由于包含了多次，预处理器还是处理了多次，所以效率上来说比较低；后者是告诉预处理器当前文件只编译一次，所以说效率较高。
下面看一个 #pragma once 的使用示例：
global.h：
#pragma once int g_value = 1;
test.c：
#include <stdio.h>
#include "global.h"
#include "global.h"
int main()
{
printf("g_value = %d\n", g_value);
return 0;
}
下面为输出结果，可以看到虽然在test.c 定义了两次global.h，但是程序编译没有报错，且能正常运行，这就是 #pragma once 作用的结果：
工程应用中既想要移植性，又想要保证效率，可以采用以下做法：
global.h：
#ifndef _GLOBAL_H_ #define _GLOBAL_H_ #pragma once int g_value = 1; #endif
四、#pragma pack
什么是内存对齐?
- 不同类型的数据在内存中按照一定的规则排列
- 而不一定是顺序的一个接一个的排列
下面想想 Test1 和 Test2 所占的内存空间是否相同?
答案是否定的，Test1 占用 12 个字节，而 Test 占用 8 个字节
为什么需要内存对齐?
- CPU对内存的读取不是连续的，而是分成块读取的，块的大小只能是1、2、4、8、16...字节
- 当读取操作的数据未对齐，则需要两次总线周期来访问内存，因此性能会大打折扣
- 某些硬件平台只能从规定的相对地址处读取特定类型的数据，否则产生硬件异常
#pragma pack 用于指定内存对齐方式
#pragma pack 能够改变编译器的默认对齐方式
例如，下面代码中，Test1 和 Test2 的内存均为 8 个字节
struct 占用的内存大小
第一个成员起始于 0 偏移处
每个成员按其类型大小和 pack 参数中较小的一个进行对齐
- 偏移地址必须能被对齐参数整除
- 结构体成员的大小取其内部长度最大的数据成员作为其大小
结构体总长度必须为所有对齐参数的整数倍
编译器在默认情况下按照 4 字节对齐。
下面通过代码，手工计算结构体所占用的内存大小
test.c：
#include <stdio.h>
#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()
int main()
{
printf("sizeof(Test1) = %d\n", sizeof(struct Test1));
printf("sizeof(Test2) = %d\n", sizeof(struct Test2));
return 0;
}
以 Test1 为例，c1 类型大小为 1 字节，而 pack 参数默认为 4，所以对齐参数取最小为 1；同理 s 的对齐参数为 2，偏移地址要被 2 整除，所以为 2；同理 c 的对齐参数为 1，偏移地址为 4；同理，i 的对齐参数为 4，因为偏移地址要能被 对齐参数 4 整除，在偏移地址 4 之后能被 4 整除的最小偏移地址为 8，所以 i 的偏移地址为 8，而 i 占用 4 个字节，所以 Test1 结构体占用的总字节数为 12 字节，这就和上面的图对应起来了。
下面再通过一个例子感受一下：
在 gcc 编译器下，test.c：
#include <stdio.h>
#pragma pack(8)
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; //4 12 8
};
#pragma pack()
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
下面为输出结果：
这里注意两点：
1.结构体成员的大小取其内部长度最大的数据成员作为其大小，所以 S1 的内存大小为 4，而pack 参数默认为 8，所以对齐参数为 4
2.一般的 pack 对齐格式分别是 1，2，4，8，16，默认的对齐格式，也就是：#pragmapack() 的情况下，会在结构体中挑选占用字节最多的类型，例如 double 占用 8 个字节
3.gcc 编译器暂时不支持 8 字节对齐，默认按照 4 字节对齐，所以 S2 中的 e 的对齐参数为 4，故 S2 占用内存大小为 20 字节。（学习采用的为 ubuntu 10.10）
如果把代码放在 VS2012 里运行，那结果就是和分析的一样，S2 占用 24 字节。
#include <stdio.h>
#pragma pack(8)
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
};
#pragma pack()
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
结果：
五、小结
#pragma 用于指示编译器完成一些特定的动作
#pragma 所定义的很多指示字是编译器特有的
- #pragma message 用于自定义编译消息
- #pragma once 用于保证头文件只被编译一次
- #pragma pack 用于指定内存对齐方式