【C语言进阶深度学习记录】十九 #pragma使用与分析

雨点打透心脏的1/2处 2022-03-17 09:56 455阅读 0赞

> ### 文章目录 ###
> 
>  *   *  1 \#pragma 概念简介
>      *   *  1.1 \#pragma message 的用法
>          *  1.2 \#pragma once 的用法
>          *  1.3 \#pragma pack 的用法
>          *   *  1.31 struct占用的内存大小如何计算
>      *  2 总结

在学习 \#pragma 之前 ，我们首先要明白一点， \#pragma 的实现，在不同的编译器之间是不同的，所以使用它的代码，基本上不能移植代码。但是它也有它自己的用处，还是要学习以下。

## 1 \#pragma 概念简介 ##

*  \#pragma 是唯一一个预处理器不处理的指令，它需要保留给编译器处理。
 *  \#pragma 用于指示编译器完成一些特殊的动作 （看后面就知道什么意思了）
 *  \#pragma 所定义的很多指示字，是编译器特有的
 *  \#pragma 在不同的编译器之间是不能移植的

> 因为不同的编译器的 \#pragma 的实现是不同的。所以：
> 
> 1.  编译器将忽略它不认识的 \#pragma 指令。
> 2.  不同的编译器可能以不同的方式来解释同一条 \#pragma 指令

一般用法为：

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

注意：不同的 parameter 参数的语法和意义各不相同

### 1.1 \#pragma message 的用法 ###

*  message的参数在大多数的编译器中都有相似的实现
 *  message参数在**编译时**，输出消息到编译输出窗口中。注意是在**编译时**，不是程序运行时。
 *  如果将message用于条件编译中，可以提示代码的版本信息。如下图所示：

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

如下代码是 \#pragma message的使用分析

*  24-1-lyy.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;
    }

> 上面的 \#error 的意思是如果没有定义上述的宏，就会将这句话在编译的时候打印出来，代表我们想要了解的错误。

*  上述代码如果这样编译，不定义宏：gcc 24-1-lyy.c -o 24-1-lyy.out 在编译时将显示错误如下：

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

*  如果这样编译，在命令行中定义宏 ANDROID23 ，gcc -DANDROID23 24-1-lyy.c -o 24-1-lyy.out 将在编译时显示如下信息：

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

> 注意一点，上述的信息是在编译的时候打印输出的，不是在程序运行的时候输出的。

### 1.2 \#pragma once 的用法 ###

首先说一下它的作用：

*  \#pragma once 用于保证头文件只被编译一次。也就是可以避免重复包含头文件。这与上一篇文章使用条件编译避免重复包含头文件的作用是一样的：[【C语言进阶深度学习记录】十八 条件编译的使用与分析][C_]
 *  \#pragma once 是编译器相关的，不一定被支持。

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

那么 \#pragma once 与之前学的条件编译来避免重复包含头文件，这两种方式有什么区别呢？

*  \#pragma once效率会更高，因为它只保证被编译一次，不会去判断是否定定义了相关宏。所以效率更高。

下面的代码：

*  24-2.c

#include <stdio.h>
    #include "global.h"
    #include "global.h"
    
    int main()
    {
        
        printf("g_value = %d\n", g_value);
    
        return 0;
    }

*  global.h

#pragma once
    
    int g_value = 1;

*  对上述代码进行编译运行：gcc 24-2.c -o 24-2.out

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

可以看出，虽然上面的代码包含了两次global头文件，但是编译并没有报错。因为在头文件中使用了\#pragma once ，使得该头文件只能被编译一次，作用与在头文件中使用条件编译指令一样。

### 1.3 \#pragma pack 的用法 ###

什么是内存对齐？

*  不同类型的数据在内存中按照一定的规则排列
 *  但是不一定是顺序的一个接一个的排列

例如下图中的两个结构体的大小是不一样的，因为它们的内存布局是不一样的：

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

它们的内存布局如下图：

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

> 至于为什么是上图这样的对齐方式，下一篇文章会进行学习。

> 先来加单的说一下为什么需要内存对齐：
> 
> 1.  CPU对内存的读取不是连续的，而是分成块读取的，块的大小只能是1,2,4,8,16…字节
> 2.  当读取的数据未对齐，则需要两次总线周期来访问内存才能将整个数据读完，这样会降低CPU性能
> 3.  某些硬件平台只能从规定的相对地址处读取特定类型的数据，否则产生**硬件异常**

*  \#pragma pack 用于指定内存的对齐方式。用于修改编译器的默认对齐方式

一般来讲，在Linux系统中，编译器的默认对我方式是4字节对齐。下图中的代码，可以将对齐方式修改为1字节对齐：

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

#### 1.31 struct占用的内存大小如何计算 ####

对于不同的内存对齐方式，上面的结构体在内存中的布局是不一样的，那么我们如何来计算不同的对齐方式在内存中的布局是什么样的呢？

需要根据以下三点：

1.  第一个struct成员永远起始于 0偏移处
2.  每个成员按其**类型大小和pack参数中较小的一个** 进行对齐
    
    2.1 偏移地址必须能被对齐参数整除  
    2.2 如果一个结构体中有一个变量也是结构体，那么这个内部的结构体成员的**对齐大小**就按照其内部最大的数据成员作为其大小来计算
3.  结构体总长度，必须为所有对齐参数的整数倍

*  只需要按照上述三点计算方法，就可以计算出所有结构体的大小以及内存布局的样式

如下面的代码：

*  24-3.c

#include <stdio.h>
    
    #pragma pack(2)
    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;
    }

*  编译运行结果为：

sizeof(Test1) = 10  
sizeof(Test2) = 8

*  结果分析1–Test1：

对于结构体Test1，2字节对齐，按照上述三个计算条件有：

struct Test1
    {
                      //对齐方式             大小         起始地址                占用的内存地址位置      
        char  c1;       2          大于     1            0                            0            
        short  s;       2          等于     2            2(被对齐参数2整除)            2~3           
        char  c2;       2          大于     1(对齐参数)   4                            4            
        int   i;        2(对齐参数) 小于     4            6(被对齐参数2整除)            6~9
    };

1.  Test1的对齐方式是2字节。

然后根据：

1.  每个成员按其**类型大小和pack参数中较小的一个** 进行对齐。比如上面的起始地址计算那里，都是被对齐参数2整除，这个2是**类型大小和pack参数中较小的一个**
    
    2.1 偏移地址必须能被对齐参数整除

这一条规则计算每个成员的起始地址。如上面的计算。

1.  最后再看总体大小是否是对齐参数的整数倍。上面Test1 大小是10，是对齐参数2的整数倍

*  结果分析2–Test2

对于结构体Test2，4字节对齐，按照上述三个计算条件有：

struct Test2
    {
                      //对齐方式         大小           起始地址                   占用的内存地址位置      
        char  c1;       4      大于    1(对齐参数)       0                             0            
        char  c2;       4      大于    1(对齐参数)       1(被对齐参数1整除)             1           
        short s;        4      大于    2(对齐参数)       2(被对齐参数2整除)             2~3          
        int   i;        4      等于    4(对齐参数)       4(被对齐参数4整除)             5~7
    };

1.  Test2 的对齐方式是4字节对齐

然后再根据：

1.  每个成员按其**类型大小和pack参数中较小的一个** 进行对齐。比如上面的起始地址计算那里，对齐参数分别为1,1,2,4
    
    2.1 偏移地址必须能被对齐参数整除

这一条规则计算每个成员的起始地址。如上面的计算。

1.  最后再看总体大小是否是对齐参数的整数倍。上面Test2 大小是8，是对齐参数4的整数倍

> 经过上面的两个结构体大小的计算，可以很容易的画出其内存图

再看一个复杂的结构体大小的计算

*  代码 24-4.c

#include <stdio.h>
    
    struct S1
    {
        
        short a;
        long b;
    };
    
    struct S2
    {
        
        char c;
        struct S1 d;
        double e;
    };
    
    
    int main()
    {
        
        printf("sizeof(struct S1) = %d\n", sizeof(struct S1));
        printf("sizeof(struct S2) = %d\n", sizeof(struct S2));
        
        return 0;
    }

运行结果为：

sizeof(struct S1) = 8  
sizeof(struct S2) = 20

S1很好分析。下面我们分析S2

struct S2         //对齐方式          大小                     起始地址    占用的内存地址位置
    {
        
        char c;           4      大于     1(对齐参数)                0                0 
        struct S1 d;      4      等于     4(这个是S1中最大参数大小)   4(被4整除)       4~11（S1实际大小为8） 
        double e;         4(对齐)小于     8                         12(被4整除)      12~19 
          };

1.  S2 的对齐方式是4字节对齐

然后再根据：

1.  每个成员按其**类型大小和pack参数中较小的一个** 进行对齐。比如上面的起始地址计算那里，对齐参数分别为0,4,12
    
    2.1 偏移地址必须能被对齐参数整除  
    2.2 如果一个结构体中有一个变量也是结构体，那么这个内部的结构体成员的**对齐大小**就按照其内部最大的数据成员作为其大小来计算

这一条规则计算每个成员的起始地址。如上面的计算。

1.  最后再看总体大小是否是对齐参数的整数倍。上面S2 大小是20，是对齐参数4的整数倍

> 我所使用的编译器gcc 4.4.5 不支持8字节对齐方式

## 2 总结 ##

*  \#pragma 用于指示编译器完成以下特殊的动作
 *  \#pragma 对于不同的编译器，可能底层实现原理不太一样
    
    1.  \#pragma message 用于自定义编译消息
    2.  \#pragma once 用于避免重复包含头文件
    3.  \#pragma pack 用于指定内存对齐方式

[20190223174502123.png_pic_center]: /images/20220317/7881b2b8b7094d489c98ac7fcaae78bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center]: /images/20220317/5b875d88bc7c4ca48204aa25afb87d92.png
[20190223180831934.png_pic_center]: /images/20220317/099f289c0dd94d3a9fe3101aa29c438c.png
[20190223181150346.png_pic_center]: /images/20220317/17bcd313f65841aca8d6691a379d6664.png
[C_]: https://blog.csdn.net/qq_37375427/article/details/87890038
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220317/8124baf0df714453aa18f635e54214dd.png
[2019022319324548.png_pic_center]: /images/20220317/37aa2e7c67f74131a9b85f34ee74900b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220317/77a16b0a01e447648ab430ce76265c27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220317/657812add0bc4f2bb2db9c218d875c1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Mzc1NDI3_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220317/a4f6b5e5ae404507912e101d2fd23c2a.png