C/C++计算类/结构体和联合体（union）所占内存大小（内存对齐问题）

心已赠人 2022-11-15 12:25 174阅读 0赞

# 内存对齐的三条规则 #

1.  数据成员对齐规则，结构体(struct)(或联合(union))的数据成员，第一个数据成员存放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员(只要该成员有子成员，比如数组、结构体等)大小的**整数倍**开始(如：int 在 64bit 目标平台下占用 4Byte，则要从4的整数倍地址开始存储)
2.  结构体作为成员，如果一个结构体里有某些结构体成员，则结构体成员要从其内部**最大元素大小的整数倍地址**开始存储
3.  结构体的总大小，即sizeof的结果，必须是其内部最大成员长度(即前面内存对齐指令中提到的有效值)的整数倍，不足的要补齐

# 注意事项： #

*  数组在内存中存储时是分开存储的，char类型的数组每个元素是 1Byte，内存对齐时按照单个元素进行对齐
 *  union(联合体)类型中的数据共用内存，联合的所有成员共用一段内存空间，存储地址的起始位置都相同，一般来说最大成员的内存宽度作为union的内存大小，主要的原因是为了节省内存空间，默认的访问权限是公有的，但是它同样要遵守内存对齐的原则，特别是第3条规则
 *  C++中空结构体占用 1Byte
 *  C++中空类同样是占用 1Byte的内存空间
 *  类和结构体一样，需要内存对齐

# 举例说明 #

struct Test1 {
        int a;
        double b;
        char c;
    };//24

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:238px;">类型</td> 
   <td style="width:75px;">int</td> 
   <td style="width:95px;">double</td> 
   <td style="width:91px;">char</td> 
  </tr> 
  <tr> 
   <td style="width:238px;">地址</td> 
   <td style="width:75px;">0~3</td> 
   <td style="width:95px;">8~15</td> 
   <td style="width:91px;">16</td> 
  </tr> 
  <tr> 
   <td style="width:238px;">累计所占内存（字节）</td> 
   <td style="width:75px;">4</td> 
   <td style="width:95px;">16</td> 
   <td style="width:91px;">17</td> 
  </tr> 
  <tr> 
   <td style="width:238px;">按照规则（最大成员长度整数倍）</td> 
   <td style="width:75px;">4</td> 
   <td style="width:95px;">16</td> 
   <td style="width:91px;">24</td> 
  </tr> 
 </tbody> 
</table>

解释：  
int a; 占用 4Byte(存储位置0-3)，规则1  
double b; 占用 8Byte(存储位置是从该类型长度(也就是 8Byte)或整数倍开始存储8-15)，规则1  
char c; 占用 1Byte(存储位置16)，规则1  
这时一共用了17 Byte，但是sizeof所得的大小为24，这就用到了第3条规则，最后sizeof的大小还必须是内部最大成员长度的整数倍，不足的要补齐，这个结构体中最大成员是double b; 8 Byte，最后sizeof的大小为24，规则3

struct Test2 {
        int a;
        double b;
        char c[6];
    };//24

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:238px;">类型</td> 
   <td style="width:75px;">int</td> 
   <td style="width:95px;">double</td> 
   <td style="width:91px;">char [6]</td> 
  </tr> 
  <tr> 
   <td style="width:238px;">地址</td> 
   <td style="width:75px;">0~3</td> 
   <td style="width:95px;">8~15</td> 
   <td style="width:91px;">16~21</td> 
  </tr> 
  <tr> 
   <td style="width:238px;">累计所占内存（字节）</td> 
   <td style="width:75px;">4</td> 
   <td style="width:95px;">16</td> 
   <td style="width:91px;">21</td> 
  </tr> 
  <tr> 
   <td style="width:238px;">按照规则（最大成员长度整数倍）</td> 
   <td style="width:75px;">4</td> 
   <td style="width:95px;">16</td> 
   <td style="width:91px;">24</td> 
  </tr> 
 </tbody> 
</table>

解释：  
int a; 占用 4Byte(存储位置0-3)，规则1  
double b; 占用 8Byte(存储位置是从该类型长度(也就是 8Byte)或整数倍开始存储8-15)，规则1  
数组在内存中存储时是分开存储的，char类型的数组每个元素是 1Byte，按单个元素进行内存对齐，故sizeof大小还是24，注意1 & 规则3

struct Test {
        int a;
        double b;
        char c;
    };
    
    struct Test3 {
        int a;
        Test d;
        double b;
        char c;
    };//48

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="width:255px;">类型</td> 
   <td style="width:53px;">int</td> 
   <td style="width:61px;"><span style="color:#f33b45;">int</span></td> 
   <td style="width:78px;"><span style="color:#f33b45;">double</span></td> 
   <td style="width:67px;"><span style="color:#f33b45;">char</span></td> 
   <td style="width:67px;">double</td> 
   <td style="width:54px;">char</td> 
  </tr> 
  <tr> 
   <td style="width:255px;">地址</td> 
   <td style="width:53px;">0~3</td> 
   <td style="width:61px;">8~11</td> 
   <td style="width:78px;">16~23</td> 
   <td style="width:67px;">24</td> 
   <td style="width:67px;">32~39</td> 
   <td style="width:54px;">40</td> 
  </tr> 
  <tr> 
   <td style="width:255px;">累计所占内存（字节）</td> 
   <td style="width:53px;">4</td> 
   <td style="width:61px;">12</td> 
   <td style="width:78px;">24</td> 
   <td style="width:67px;">25</td> 
   <td style="width:67px;">40</td> 
   <td style="width:54px;">41</td> 
  </tr> 
  <tr> 
   <td style="width:255px;">按照规则（最大成员长度整数倍）</td> 
   <td style="width:53px;">&nbsp;</td> 
   <td style="width:61px;">&nbsp;</td> 
   <td style="width:78px;">&nbsp;</td> 
   <td style="width:67px;">&nbsp;</td> 
   <td style="width:67px;">&nbsp;</td> 
   <td style="width:54px;">48</td> 
  </tr> 
 </tbody> 
</table>

int a; 占用 4Byte(存储位置0-3)，规则1  
Test中最大的元素是double b; 占用 8Byte，Test中的成员是按照 8Byte 的整数倍的地址开始存储的，Test中int a; 占用 4Byte(存储位置8-11)，double b; 占用 8Byte(存储位置16-23)，char c; 占用 1Byte(存储位置24)，规则2  
double b; 占用 8Byte(存储位置32-39)，规则1  
char c; 占用1 Byte(存储位置40)，40是最大元素大小8的整数倍，但是要大于40，按照规则3补齐，sizeof为48，规则1 & 规则2 & 规则3

struct Test {
        int a;
        double b;
        char c;
    };
    
    struct Test3 {
        int a;
        Test d;
        char c;
    };//40

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="width:255px;">类型</td> 
   <td style="width:53px;">int</td> 
   <td style="width:61px;"><span style="color:#f33b45;">int</span></td> 
   <td style="width:78px;"><span style="color:#f33b45;">double</span></td> 
   <td style="width:67px;"><span style="color:#f33b45;">char</span></td> 
   <td style="width:54px;">char</td> 
  </tr> 
  <tr> 
   <td style="width:255px;">地址</td> 
   <td style="width:53px;">0~3</td> 
   <td style="width:61px;">8~11</td> 
   <td style="width:78px;">16~23</td> 
   <td style="width:67px;">24</td> 
   <td style="width:54px;">32</td> 
  </tr> 
  <tr> 
   <td style="width:255px;">累计所占内存（字节）</td> 
   <td style="width:53px;">4</td> 
   <td style="width:61px;">12</td> 
   <td style="width:78px;">24</td> 
   <td style="width:67px;">25</td> 
   <td style="width:54px;">33</td> 
  </tr> 
  <tr> 
   <td style="width:255px;">按照规则（最大成员长度整数倍）</td> 
   <td style="width:53px;">&nbsp;</td> 
   <td style="width:61px;">&nbsp;</td> 
   <td style="width:78px;">24</td> 
   <td style="width:67px;">32</td> 
   <td style="width:54px;">40</td> 
  </tr> 
 </tbody> 
</table>

Test3中的最大数据成员大小比成员结构体Test内部最大成员大小要小，这时规则3是按照**成员结构体内部的最大成员的整数倍进行补齐**的，sizeof的结果是40

# 联合体（union） #

**找到联合体中最大的数据类型，还必须满足是所有成员的整数倍**

union Test{
        char a[20];
        int b;
        float c;
    };

sizeof的大小是20，即a\[20\]的大小，同样20是b和c的倍数，规则3

union Test{
        char a[20];
        int b;
        float c;
        double d;
    };

sizeof的大小是24，即满足容下a\[20\]，同样20是b、c和d的倍数，规则3

# 字节对齐的原因： #

*  平台原因(移植原因)，不是所有的硬件平台都能任意访问地址上的任意数据的，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常
 *  性能原因，经过内存对齐后，CPU的访问效率会得到很大的提高(CPU把内存当成是一块一块的，块的大小可以是2，4，8，16Byte 大小，因此CPU在读取内存时是一块一块进行读取的，当读取块的大小是 4Byte 时，一个数据所占的字节偏移(offset)为3|4|5|6，那么CPU访问数据时便需要访问两次，才能得到完整的数据，经过内存对齐后，便可以通过一次访问CPU获取完整的数据

# 计算练习 #

struct s1{
        char ch1;
        char ch2;
        int i;
    };//8
    
    struct s2{
        char ch1;
        int i;
        char ch2;
    };//12
    
    struct s3{
        char ch;
        int i;
        char str[10];
    };//20
    
    struct s4{
        char ch;
        int i;
        struct s{
            char ch1;
            int j;
        }sub;
        float f;
    };//20
    
    struct s5{
        char ch;
        char i;
        struct s{
            char ch1;
            double j;
        }sub;
        char f;
    };//32