你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

C语言结构体对齐问题

[复制链接]
gaosmile 发布时间：2020-6-17 13:01
C语言结构体对齐问题，是面试必备问题。
本文，除了用图解的方式讲清楚结构体知识点外，还将为你解答以下问题：
  • 为什么会有结构体内存对齐？
  • 结构体怎么对齐？
  • 学习结构体对齐有什么用？
  • 结构体对齐有没有实际应用？

▍结构体内存对齐的原因

一句话，为了提高效率，这个跟芯片设计有关。
自从我们刚学习编程开始，就会接触到例如字、双字、四字等概念这里涉及到内存边界问题，它们的地址分别是可被2/4/8整除的。另外，在汇编中，不同长度的内存访问会用到不同的汇编指令。如果，一块内存在地址上随便放的，CPU有可能就会用到多条指令来访问，这就会降低效率。对于32位系统，如下图的A可能需要2条指令访问，而B只需1条指令。
微信图片_20200617125952.png
微信图片_20200617125955.png
▍结构体内存对齐的规则
1. C语言基本类型的大小
不要瞎猜，直接上代码。每个平台都不一样，请读者自行测试，以下我是基于Windows上MinGW的GCC测的。

  2. #define BASE_TYPE_SIZE(t)   printf("%12s : %2d Byte%s\n", #t, sizeof(t), (sizeof(t))>1?"s":"")
  3. void base_type_size(void)
  4. {
  5.     BASE_TYPE_SIZE(void);
  6.     BASE_TYPE_SIZE(char);
  7.     BASE_TYPE_SIZE(short);
  8.     BASE_TYPE_SIZE(int);
  9.     BASE_TYPE_SIZE(long);
  10.     BASE_TYPE_SIZE(long long);
  11.     BASE_TYPE_SIZE(float);
  12.     BASE_TYPE_SIZE(double);
  13.     BASE_TYPE_SIZE(long double);
  14.     BASE_TYPE_SIZE(void*);
  15.     BASE_TYPE_SIZE(char*);
  16.     BASE_TYPE_SIZE(int*);
  17.    
  18.     typedef struct
  19.     {
  20.     }StructNull;
  21.     BASE_TYPE_SIZE(StructNull);
  22.     BASE_TYPE_SIZE(StructNull*);
  23. }
复制代码

结果是：

  2.         void :  1 Byte
  3.         char :  1 Byte
  4.        short :  2 Bytes
  5.          int :  4 Bytes
  6.         long :  4 Bytes
  7.    long long :  8 Bytes
  8.        float :  4 Bytes
  9.       double :  8 Bytes
  10. long double : 12 Bytes
  11.        void* :  4 Bytes
  12.        char* :  4 Bytes
  13.         int* :  4 Bytes
  14.   StructNull :  0 Byte
  15. StructNull* :  4 Bytes
复制代码


这些内容不用记住，不同平台是不一样的，使用之前，一定要亲自测试验证下，但是可以总结出以下信息：
  • void类型不是空的，占一个字节
  • long不一定比int大
  • C语言空结构体的大小为0（注意：C++的为1）
  • 不管什么类型，指针都是相同大小的


2. C语言结构体的内存对齐
我先看个例子：

  2. #define offset(type, member)      (size_t)&(((type *)0)->member)
  3. #define STRUCT_E_ADDR(s,e)          printf("%5s size = %2d %16s addr: %p\n", #s, sizeof(s), #s"."#e, &s.e)
  4. #define STRUCT_E_OFFSET(s,e)        printf("%5s size = %2d %16s offset: %2d\n", #s, sizeof(s), #s"."#e, offset(__typeof__(s),e))
  5. #define STRUCT_E_ADDR_OFFSET(s,e)   printf("%5s size = %2d %16s addr: %p, offset: %2d\n", #s, sizeof(s), #s"."#e, &s.e, offset(__typeof__(s),e))

  7. typedef struct
  8. {
  9.     int e_int;
  10.     char e_char;
  11. }S1;
  12. S1 s1;
  13. STRUCT_E_ADDR_OFFSET(s1, e_int);
  14. STRUCT_E_ADDR_OFFSET(s1, e_char);
  15. typedef struct
  16. {
  17.     int e_int;
  18.     double e_double;
  19. }S11;
  20. S11 s11;
  21. STRUCT_E_ADDR_OFFSET(s11, e_int);
  22. STRUCT_E_ADDR_OFFSET(s11, e_double);
复制代码


咦……这宏定义是啥意思？传送门：《基于C99规范，最全C语言预处理知识总结》输出结果：

  2.    s1 size =  8         s1.e_int addr: 0028FF28, offset:  0
  3.    s1 size =  8        s1.e_char addr: 0028FF2C, offset:  4
  4.   s11 size = 16        s11.e_int addr: 0028FF18, offset:  0
  5.   s11 size = 16     s11.e_double addr: 0028FF20, offset:  8
复制代码

结论1：一般情况下，结构体所占的内存大小并非元素本身大小之和。

结论2：不严谨地，结构体内存的大小按最大元素大小对齐。
继续看例子：

  2.     typedef struct
  3.     {
  4.         int e_int;
  5.         long double e_ld;
  6.     }S12;

  8.     typedef struct
  9.     {
  10.         long long e_ll;
  11.         long double e_ld;
  12.     }S13;

  14.     typedef struct
  15.     {
  16.         char e_char;
  17.         long double e_ld;
  18.     }S14;

  20.     S12 s12;
  21.     S13 s13;
  22.     S14 s14;
  23.     STRUCT_E_ADDR_OFFSET(s12, e_int);
  24.     STRUCT_E_ADDR_OFFSET(s12, e_ld);
  25.     STRUCT_E_ADDR_OFFSET(s13, e_ll);
  26.     STRUCT_E_ADDR_OFFSET(s13, e_ld);
  27.     STRUCT_E_ADDR_OFFSET(s14, e_char);
  28.     STRUCT_E_ADDR_OFFSET(s14, e_ld);
复制代码

输出结果：

  2.   s12 size = 16        s12.e_int addr: 0028FF08, offset:  0
  3.   s12 size = 16         s12.e_ld addr: 0028FF0C, offset:  4
  4.   s13 size = 24         s13.e_ll addr: 0028FEF0, offset:  0
  5.   s13 size = 24         s13.e_ld addr: 0028FEF8, offset:  8
  6.   s14 size = 16       s14.e_char addr: 0028FEE0, offset:  0
  7.   s14 size = 16         s14.e_ld addr: 0028FEE4, offset:  4
复制代码


出现问题了，你看s12和s14，sizeof(long long)应该是12，按结论而推断sizeof(s12)和sizeof(s13)应该都是24。
这里跟平台和编译器的一个模数有关。
对结论2修正：结构体内存大小应按最大元素大小对齐，如果最大元素大小超过模数，应按模数大小对齐。
额外再送一条结论：如果结构体的最大元素大小超过模数，结构体的起始地址是可以被模数整除的。如果，最大元素大小没有超过模数大小，那它的起始地址是可以被最大元素大小整除。
那么，这个模数是什么？
每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。
网上流传一个表：
平台
长度/模数
char
short
int
long
float
double
long long
long double
Win-32
长度
1
2
4
4
4
8
8
8
模数
1
2
4
4
4
8
8
8
Linux-32
长度
1
2
4
4
4
8
8
12
模数
1
2
4
4
4
4
4
4
Linux-64
长度
1
2
4
8
4
8
8
16
模数
1
2
4
8
4
8
8
16
本文的的例子我用的是MinGW32的GCC来测试，你猜符合上表的哪一项？
别急，再看一个例子：

  2.     typedef struct
  3.     {
  4.         int e_int;
  5.         double e_double;
  6.     }S11;
  7.     S11 s11;
  8.     STRUCT_E_ADDR_OFFSET(s11, e_int);
  9.     STRUCT_E_ADDR_OFFSET(s11, e_double);
复制代码


结果是：

  2.   s11 size = 16        s11.e_int addr: 0028FF18, offset:  0
  3.   s11 size = 16     s11.e_double addr: 0028FF20, offset:  8
复制代码


很明显，上表没有一项完全对应得上的。简单汇总以下我测试的结果：
长度/模数
char
short
int
long
float
double
long long
long double
长度
1
2
4
4
4
8
8
12
模数
1
2
4
4
4
8
8
8
所以，再强调一下：因为环境的差异，在你参考使用之前，请自行测试一下。另外，提一下：这个模数是可以改变的，可以用预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。例如

  2. #pragma pack(1)
  3. typedef struct
  4. {
  5.     char e_char;
  6.     long double e_ld;
  7. }S14;
  8. #pragma pack()
复制代码


#pragma是啥玩意？有兴趣可以看看：《基于C99规范，最全C语言预处理知识总结》
好了，我们继续，这似乎没啥技术含量，我们提升下难度：

  2.     typedef struct
  3.     {
  4.         int e_int;
  5.         char e_char1;
  6.         char e_char2;
  7.     }S2;

  9.     typedef struct
  10.     {
  11.         char e_char1;
  12.         int e_int;
  13.         char e_char2;
  14.     }S3;
  15.     S2 s2;
  16.     S3 s3;
复制代码


你觉得这俩结构体所占内存是一样大吗？那你就错了：

  2.    s2 size =  8         s2.e_int addr: 0028FED4, offset:  0
  3.    s2 size =  8       s2.e_char1 addr: 0028FED8, offset:  4
  4.    s2 size =  8       s2.e_char2 addr: 0028FED9, offset:  5
  5.    s3 size = 12       s3.e_char1 addr: 0028FEC4, offset:  0
  6.    s3 size = 12         s3.e_int addr: 0028FEC8, offset:  4
  7.    s3 size = 12       s3.e_char2 addr: 0028FECC, offset:  8
复制代码


why？
上个图先看看，它们内存是怎么对齐的：
微信图片_20200617125959.png
我们套一遍那几条结论就可以知道：
理解按最大元素大小或模数对齐，就可以看到S2的内存分布；
对于S3，e_int的位置地址，肯定是要按int的大小对齐的（地址可被int大小整除），这样才能提高访问效率。同时，这导致了很大的内存浪费。
以上例子，我们看到挨在一起的两个char会放在同一个对齐单元，如果挨在一起的short和char会不会放一起？

  2.     typedef struct
  3.     {
  4.         char e_char1;
  5.         short e_short;
  6.         char e_char2;
  7.         int e_int;
  8.         char e_char3;
  9.     }S4;
  10.     S4 s4;
  11.     STRUCT_E_ADDR_OFFSET(s4, e_char1);
  12.     STRUCT_E_ADDR_OFFSET(s4, e_short);
  13.     STRUCT_E_ADDR_OFFSET(s4, e_char2);
  14.     STRUCT_E_ADDR_OFFSET(s4, e_int);
  15.     STRUCT_E_ADDR_OFFSET(s4, e_char3);
复制代码


输出结果：

  2.    s4 size = 16       s4.e_char1 addr: 0028FEB4, offset:  0
  3.    s4 size = 16       s4.e_short addr: 0028FEB6, offset:  2
  4.    s4 size = 16       s4.e_char2 addr: 0028FEB8, offset:  4
  5.    s4 size = 16         s4.e_int addr: 0028FEBC, offset:  8
  6.    s4 size = 16       s4.e_char3 addr: 0028FEC0, offset: 12
复制代码


微信图片_20200617130003.png
得出一个经验：
我们在定义结构体的时候，尽量把大小相同或相近的元素放一起，以减少结构体占用的内存空间。
再来一个问题：
结构体套着另一个结构体怎么计算？

  2.     typedef struct
  3.     {
  4.         int e_int;
  5.         char e_char;
  6.     }S1;
  7.    typedef struct
  8.     {
  9.         S1 e_s;
  10.         char e_char;
  11.     }SS1;

  13.     typedef struct
  14.     {
  15.         short e_short;
  16.         char e_char;
  17.     }S6;

  19.     typedef struct
  20.     {
  21.         S6 e_s;
  22.         char e_char;
  23.     }SS2;
  24.    
  25.     SS1 ss1;
  26.     STRUCT_E_ADDR_OFFSET(ss1, e_s);
  27.     STRUCT_E_ADDR_OFFSET(ss1, e_char);

  29.     SS2 ss2;
  30.     STRUCT_E_ADDR_OFFSET(ss2, e_s);
  31.     STRUCT_E_ADDR_OFFSET(ss2, e_char);
复制代码


输出结果：

  2.   ss1 size = 12          ss1.e_s addr: 0028FE94, offset:  0
  3.   ss1 size = 12       ss1.e_char addr: 0028FE9C, offset:  8
  4.   ss2 size =  6          ss2.e_s addr: 0028FE8E, offset:  0
  5.   ss2 size =  6       ss2.e_char addr: 0028FE92, offset:  4
复制代码


微信图片_20200617130006.png
得出结论：结构体内的结构体，结构体内的元素并不会和结构体外的元素合并占一个对齐单元。
温馨提示：大家不要刻意去记这些结论，动手去试试并思考下效果会更好。
3. 联合体union的内存对齐
直接上代码：

  2.     typedef union
  3.     {
  4.         char e_char;
  5.         int e_int;
  6.     }U1;

  8.     U1 u1;
  9.     STRUCT_E_ADDR(u1, e_char);
  10.     STRUCT_E_ADDR(u1, e_int);
复制代码


输出结果：

  2.    u1 size =  4        u1.e_char addr: 0028FF2C
  3.    u1 size =  4         u1.e_int addr: 0028FF2C
复制代码


从教科书上，我都可以理解，联合体里面的元素，实际上共享同一个空间。
微信图片_20200617130009.png
那么，union跟struct结合呢？

  2.     typedef struct
  3.     {
  4.         int e_int1;
  5.         union
  6.         {
  7.             char ue_chars[9];
  8.             int ue_int;
  9.         }u;
  10.         double e_double;
  11.         int e_int2;
  12.     }SU2;
  13.     SU2 su2;
  14.     STRUCT_E_ADDR_OFFSET(su2, e_int1);
  15.     STRUCT_E_ADDR_OFFSET(su2, u.ue_chars);
  16.     STRUCT_E_ADDR_OFFSET(su2, u.ue_int);
  17.     STRUCT_E_ADDR_OFFSET(su2, e_double);
  18.     STRUCT_E_ADDR_OFFSET(su2, e_int2)
复制代码

输出：

  2.   su2 size = 32       su2.e_int1 addr: 0028FEF8, offset:  0
  3.   su2 size = 32   su2.u.ue_chars addr: 0028FEFC, offset:  4
  4.   su2 size = 32     su2.u.ue_int addr: 0028FEFC, offset:  4
  5.   su2 size = 32     su2.e_double addr: 0028FF08, offset: 16
  6.   su2 size = 32       su2.e_int2 addr: 0028FF10, offset: 24
复制代码

微信图片_20200617130012.png
实际上跟结构体类似，也没有特别的规则。
顺便提一下，使用union时，要留意平台的大小端问题。
大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
小端模式，是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。
百度百科——大小端模式
怎么获知自己使用的平台的大小端？Linux有个方法：

  2.     static union {
  3.         char c[4];
  4.         unsigned long l;
  5.     } endian_test = { { 'l', '?', '?', 'b' } };
  6.     #define ENDIANNESS ((char)endian_test.l)

  8.     printf("ENDIANNESS: %c\n", ENDIANNESS);
复制代码


4. 位域（Bitfield）的相关
位域在本文没什么好探讨的，在结构体对齐方面没什么特别的地方。
直接看个测试代码，就可以明白：

  2. void bitfield_type_size(void)
  3. {
  4.     typedef struct
  5.     {
  6.         char bf1:1;
  7.         char bf2:1;
  8.         char bf3:1;
  9.         char bf4:3;
  10.     }SB1;

  12.     typedef struct
  13.     {
  14.         char bf1:1;
  15.         char bf2:1;
  16.         char bf3:1;
  17.         char bf4:7;
  18.     }SB2;

  20.     typedef struct
  21.     {
  22.         char bf1:1;
  23.         char bf2:1;
  24.         char bf3:1;
  25.         int  bfint:1;
  26.     }SB3;

  28.     typedef struct
  29.     {
  30.         char bf1:1;
  31.         char bf2:1;
  32.         int  bfint:1;
  33.         char bf3:1;
  34.     }SB4;

  36.     SB1 sb1;
  37.     SB2 sb2;
  38.     SB3 sb3;
  39.     SB4 sb4;
  40.     VAR_ADDR(sb1);
  41.     VAR_ADDR(sb2);
  42.     VAR_ADDR(sb3);
  43.     VAR_ADDR(sb4);
  44.    
  45.     typedef struct
  46.     {
  47.         unsigned char bf1:1;
  48.         unsigned char bf2:1;
  49.         unsigned char bf3:1;
  50.         unsigned char bf4:3;
  51.     }SB11;

  53.     typedef union
  54.     {
  55.         SB11 sb1;
  56.         unsigned char  e_char;
  57.     }UB1;
  58.     UB1 ub1;

  60.     STRUCT_E_ADDR_OFFSET(ub1, sb1);
  61.     STRUCT_E_ADDR_OFFSET(ub1, e_char);

  63.     ub1.e_char = 0xF5;
  64.     BITFIELD_VAL(ub1, e_char);
  65.     BITFIELD_VAL(ub1, sb1.bf1);
  66.     BITFIELD_VAL(ub1, sb1.bf2);
  67.     BITFIELD_VAL(ub1, sb1.bf3);
  68.     BITFIELD_VAL(ub1, sb1.bf4);
  69. }
复制代码

输出结果是：

  2.   sb1 size =  1        sb1 addr: 0028FF2F
  3.   sb2 size =  2        sb2 addr: 0028FF2D
  4.   sb3 size =  8        sb3 addr: 0028FF24
  5.   sb4 size = 12        sb4 addr: 0028FF18
  6.   ub1 size =  1          ub1.sb1 addr: 0028FF17, offset:  0
  7.   ub1 size =  1       ub1.e_char addr: 0028FF17, offset:  0
  8.          ub1 :  1 Byte, ub1.e_char=0xF5
  9.          ub1 :  1 Byte, ub1.sb1.bf1=0x1
  10.          ub1 :  1 Byte, ub1.sb1.bf2=0x0
  11.          ub1 :  1 Byte, ub1.sb1.bf3=0x1
  12.          ub1 :  1 Byte, ub1.sb1.bf4=0x6
复制代码

有几个点需要注意下：
  • 内存的计算单位是byte，不是bit
  • 结构体内即使有bitfield元素，其对齐规则还是按照基本类型来
  • bitfield元素不能获得其地址（即程序中不能通过&取址）


5. 规则总结首先，不推荐记忆这些条条框框的文字，以下内容仅供参考：
  • 结构体的内存大小，并非其内部元素大小之和；
  • 结构体变量的起始地址，可以被最大元素基本类型大小或者模数整除；
  • 结构体的内存对齐，按照其内部最大元素基本类型或者模数大小对齐；
  • 模数在不同平台值不一样，也可通过#pragma pack(n)方式去改变；
  • 如果空间地址允许，结构体内部元素会拼凑一起放在同一个对齐空间；
  • 结构体内有结构体变量元素，其结构体并非展开后再对齐；
  • union和bitfield变量也遵循结构体内存对齐原则。

▍编程为什么要关注结构体内存对齐也许你会问，结构体爱怎么对齐就怎么对齐，我管它干嘛！
1. 节省内存在嵌入式软件开发中，特别是内存资源匮乏的小MCU，这个尤为重要。如果优化程序内存，使得MCU可以选更小的型号，对于大批量出货的产品，可以带来更高利润。也许你还还感觉不到，上段代码：

  2.     typedef struct
  3.     {
  4.         int e_int;
  5.         char e_char1;
  6.         char e_char2;
  7.     }S2;

  9.     typedef struct
  10.     {
  11.         char e_char1;
  12.         int e_int;
  13.         char e_char2;
  14.     }S3;
  15.    
  16.     S2 s2[1024] = {0};
  17.     S3 s3[1024] = {0};
复制代码


s2的大小为8K，而s3的大小为12K，一放大，就有很明显的区别了。
2. union的内存对齐需要对于同一个内存，有时为了满足不同的访问形式，定义一个联合体变量，或者一个结构体和联合体组合的变量。此时就要知道其内存结构是怎么分布的。
3. 内存拷贝
有时候，我们在通信数据接收处理时候，往往遇到，数组和结构体的搭配。
即，通信时候，通常使用数组参数形式接收，而处理的时候，按照预定义格式去访问处理。例如：

  2. U8 comm_data[10];
  3. typedef struct
  4. {
  5.     U8 id;
  6.     U16 len;
  7.     U8 data[6];
  8. }FRAME;

  10. FRAME* pFram = (FRAME*)comm_data;
复制代码

此处，必须要理解这个FRAM的内存结构是怎么样的对齐规则。
4. 调试仿真时看压栈数据在调试某些奇葩问题时，迫不得已，我们会研究函数跳转或者线程切换时的栈数据，遇到结构体内容，肯定要懂得其内存对齐方式才能更好地获得栈内信息。
当然，还有其他方面的原因，在此就不一一列举了。
▍结构体内存对齐实际应用
上面一个章节已经部分讲到这个结构体内存对齐的应用了，例如通信数据的处理等。另外，再举两个例子：1. 内存的mapping假设你要做一个烧录文件，你想往文件头空间128个字节内放一段项目信息（例如程序大小、CRC校验码、其他项目信息等）。第一反应，你会考虑用一个结构体，定义一段这样的数据，程序运行的时候也定义同样的结构体去读取这个内存。但是你需要知道结构体大小啊，这个结构体内存对齐的规则还是需要了解的。2. 单片机寄存器的mapping在写MCU驱动的时候，访问寄存器的方式有很多种，但是做到清晰明了，适配性好的，往往需要诸多考量。
直接通过整型指针指到特定地址去访问，是没有问题的，但是对于某一类型的寄存器，往往不是一个固定地址，其后面还有一堆子寄存器属性需要配置。每个地址都通过整型指针访问，那就很多很凌乱。我们可以通过定义一个特定的结构体，用其指针直接mapping到寄存器的base地址。但是遇到有些地址是空的怎么办？甚至有些寄存器是32位的，有些16位，甚至8位的，各种参差不齐都在里面。那就要考虑结构体内存对齐了，特别是结构体内有不同类型的元素。
微信图片_20200617130015.png
这里只探讨应用场景，具体实现还要根据实际情况来定义。

▍测试源码

  2. #include <stdio.h>

  4. #define offset(type, member)      (size_t)&(((type *)0)->member)

  6. #define STRUCT_E_ADDR(s,e)          printf("%5s size = %2d %16s addr: %p\n", #s, sizeof(s), #s"."#e, &s.e)
  7. #define STRUCT_E_OFFSET(s,e)        printf("%5s size = %2d %16s offset: %2d\n", #s, sizeof(s), #s"."#e, offset(__typeof__(s),e))
  8. #define STRUCT_E_ADDR_OFFSET(s,e)   printf("%5s size = %2d %16s addr: %p, offset: %2d\n", #s, sizeof(s), #s"."#e, &s.e, offset(__typeof__(s),e))
  9. #define VAR_ADDR(v)                 printf("%5s size = %2d %10s addr: %p\n", #v, sizeof(v), #v, &v)
  10. // #define BASE_TYPE_SIZE(t)   printf("%18s = %d\n", "sizeof("#t")", sizeof(t))
  11. #define BASE_TYPE_SIZE(t)           printf("%12s : %2d Byte%s\n", #t, sizeof(t), (sizeof(t))>1?"s":"")
  12. #define BITFIELD_VAL(s,e)           printf("%12s : %2d Byte%s, %10s=0x%X\n", #s, sizeof(s), (sizeof(s))>1?"s":"", #s"."#e, s.e)

  14. void base_type_size(void)
  15. {
  16.     BASE_TYPE_SIZE(void);
  17.     BASE_TYPE_SIZE(char);
  18.     BASE_TYPE_SIZE(short);
  19.     BASE_TYPE_SIZE(int);
  20.     BASE_TYPE_SIZE(long);
  21.     BASE_TYPE_SIZE(long long);
  22.     BASE_TYPE_SIZE(float);
  23.     BASE_TYPE_SIZE(double);
  24.     BASE_TYPE_SIZE(long double);
  25.     BASE_TYPE_SIZE(void*);
  26.     BASE_TYPE_SIZE(char*);
  27.     BASE_TYPE_SIZE(int*);
  28. }
  29. void struct_type_size(void)
  30. {
  31.     typedef struct
  32.     {
  33.     }StructNull;

  35.     typedef struct
  36.     {
  37.         int e_int;
  38.         char e_char;
  39.     }S1;
  40.     BASE_TYPE_SIZE(StructNull);
  41.     BASE_TYPE_SIZE(StructNull*);
  42.    
  43.     S1 s1;
  44.     STRUCT_E_ADDR_OFFSET(s1, e_int);
  45.     STRUCT_E_ADDR_OFFSET(s1, e_char);

  47.     typedef struct
  48.     {
  49.         int e_int;
  50.         double e_double;
  51.     }S11;

  53.     typedef struct
  54.     {
  55.         int e_int;
  56.         long double e_ld;
  57.     }S12;

  59.     typedef struct
  60.     {
  61.         long long e_ll;
  62.         long double e_ld;
  63.     }S13;

  65.     typedef struct
  66.     {
  67.         char e_char;
  68.         long double e_ld;
  69.     }S14;

  71.     S11 s11;
  72.     S12 s12;
  73.     S13 s13;
  74.     S14 s14;
  75.     STRUCT_E_ADDR_OFFSET(s11, e_int);
  76.     STRUCT_E_ADDR_OFFSET(s11, e_double);
  77.     STRUCT_E_ADDR_OFFSET(s12, e_int);
  78.     STRUCT_E_ADDR_OFFSET(s12, e_ld);
  79.     STRUCT_E_ADDR_OFFSET(s13, e_ll);
  80.     STRUCT_E_ADDR_OFFSET(s13, e_ld);
  81.     STRUCT_E_ADDR_OFFSET(s14, e_char);
  82.     STRUCT_E_ADDR_OFFSET(s14, e_ld);

  84.     typedef struct
  85.     {
  86.         int e_int;
  87.         char e_char1;
  88.         char e_char2;
  89.     }S2;

  91.     typedef struct
  92.     {
  93.         char e_char1;
  94.         int e_int;
  95.         char e_char2;
  96.     }S3;
  97.     typedef struct
  98.     {
  99.         char e_char1;
  100.         short e_short;
  101.         char e_char2;
  102.         int e_int;
  103.         char e_char3;
  104.     }S4;
  105.     typedef struct
  106.     {
  107.         long long e_ll;
  108.         int e_int;
  109.     }S5;

  111.     typedef struct
  112.     {
  113.         S1 e_s;
  114.         char e_char;
  115.     }SS1;

  117.     typedef struct
  118.     {
  119.         short e_short;
  120.         char e_char;
  121.     }S6;

  123.     typedef struct
  124.     {
  125.         S6 e_s;
  126.         char e_char;
  127.     }SS2;


  130.     char var1;
  131.     S2 s2;
  132.     char var2;
  133.     S3 s3;
  134.     VAR_ADDR(var1);
  135.     STRUCT_E_ADDR_OFFSET(s2, e_int);
  136.     STRUCT_E_ADDR_OFFSET(s2, e_char1);
  137.     STRUCT_E_ADDR_OFFSET(s2, e_char2);
  138.     VAR_ADDR(var2);
  139.     STRUCT_E_ADDR_OFFSET(s3, e_char1);
  140.     STRUCT_E_ADDR_OFFSET(s3, e_int);
  141.     STRUCT_E_ADDR_OFFSET(s3, e_char2);
  142.     S4 s4;
  143.     STRUCT_E_ADDR_OFFSET(s4, e_char1);
  144.     STRUCT_E_ADDR_OFFSET(s4, e_short);
  145.     STRUCT_E_ADDR_OFFSET(s4, e_char2);
  146.     STRUCT_E_ADDR_OFFSET(s4, e_int);
  147.     STRUCT_E_ADDR_OFFSET(s4, e_char3);
  148.     S5 s5;
  149.     STRUCT_E_ADDR_OFFSET(s5, e_ll);
  150.     STRUCT_E_ADDR_OFFSET(s5, e_int);
  151.     SS1 ss1;
  152.     STRUCT_E_ADDR_OFFSET(ss1, e_s);
  153.     STRUCT_E_ADDR_OFFSET(ss1, e_char);

  155.     SS2 ss2;
  156.     STRUCT_E_ADDR_OFFSET(ss2, e_s);
  157.     STRUCT_E_ADDR_OFFSET(ss2, e_char);
  158. }

  160. void union_type_size(void)
  161. {
  162.     typedef union
  163.     {
  164.         char e_char;
  165.         int e_int;
  166.     }U1;

  168.     U1 u1;
  169.     STRUCT_E_ADDR_OFFSET(u1, e_char);
  170.     STRUCT_E_ADDR_OFFSET(u1, e_int);
  171.    

  173.     typedef struct
  174.     {
  175.         short e_short;
  176.         union
  177.         {
  178.             char ue_chars[9];
  179.             int ue_int;
  180.         }u;
  181.     }SU1;

  183.     typedef struct
  184.     {
  185.         int e_int1;
  186.         union
  187.         {
  188.             char ue_chars[9];
  189.             int ue_int;
  190.         }u;
  191.         double e_double;
  192.         int e_int2;
  193.     }SU2;

  195.     SU1 su1;
  196.     SU2 su2;
  197.    
  198.     STRUCT_E_ADDR_OFFSET(su1, e_short);
  199.     STRUCT_E_ADDR_OFFSET(su1, u.ue_chars);
  200.     STRUCT_E_ADDR_OFFSET(su1, u.ue_int);
  201.    
  202.     STRUCT_E_ADDR_OFFSET(su2, e_int1);
  203.     STRUCT_E_ADDR_OFFSET(su2, u.ue_chars);
  204.     STRUCT_E_ADDR_OFFSET(su2, u.ue_int);
  205.     STRUCT_E_ADDR_OFFSET(su2, e_double);
  206.     STRUCT_E_ADDR_OFFSET(su2, e_int2);
  207. }

  209. void bitfield_type_size(void)
  210. {
  211.     typedef struct
  212.     {
  213.         char bf1:1;
  214.         char bf2:1;
  215.         char bf3:1;
  216.         char bf4:3;
  217.     }SB1;

  219.     typedef struct
  220.     {
  221.         char bf1:1;
  222.         char bf2:1;
  223.         char bf3:1;
  224.         char bf4:7;
  225.     }SB2;

  227.     typedef struct
  228.     {
  229.         char bf1:1;
  230.         char bf2:1;
  231.         char bf3:1;
  232.         int  bfint:1;
  233.     }SB3;

  235.     typedef struct
  236.     {
  237.         char bf1:1;
  238.         char bf2:1;
  239.         int  bfint:1;
  240.         char bf3:1;
  241.     }SB4;

  243.     SB1 sb1;
  244.     SB2 sb2;
  245.     SB3 sb3;
  246.     SB4 sb4;
  247.     // STRUCT_E_OFFSET(sb1, bf1);
  248.     // STRUCT_E_OFFSET(sb1, bf2);
  249.     // STRUCT_E_OFFSET(sb1, bf3);
  250.     // STRUCT_E_OFFSET(sb1, bf4);
  251.     VAR_ADDR(sb1);
  252.     VAR_ADDR(sb2);
  253.     VAR_ADDR(sb3);
  254.     VAR_ADDR(sb4);
  255.    
  256.     typedef struct
  257.     {
  258.         unsigned char bf1:1;
  259.         unsigned char bf2:1;
  260.         unsigned char bf3:1;
  261.         unsigned char bf4:3;
  262.     }SB11;

  264.     typedef union
  265.     {
  266.         SB11 sb1;
  267.         unsigned char  e_char;
  268.     }UB1;
  269.     UB1 ub1;

  271.     STRUCT_E_ADDR_OFFSET(ub1, sb1);
  272.     STRUCT_E_ADDR_OFFSET(ub1, e_char);

  274.     ub1.e_char = 0xF5;
  275.     BITFIELD_VAL(ub1, e_char);
  276.     BITFIELD_VAL(ub1, sb1.bf1);
  277.     BITFIELD_VAL(ub1, sb1.bf2);
  278.     BITFIELD_VAL(ub1, sb1.bf3);
  279.     BITFIELD_VAL(ub1, sb1.bf4);

  281.     static union {
  282.         char c[4];
  283.         unsigned long l;
  284.     } endian_test = { { 'l', '?', '?', 'b' } };
  285.     #define ENDIANNESS ((char)endian_test.l)

  287.     printf("ENDIANNESS: %c\n", ENDIANNESS);

  289. }
  290. int main(void)
  291. {
  292.     // base_type_size();
  293.     struct_type_size();
  294.     union_type_size();
  295.     bitfield_type_size();

  297.     return 0;
  298. }
复制代码


赞 收藏 评论0 发布时间：2020-6-17 13:01

举报

0个回答

所属标签

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版