关于C++中sizeof()的一些问题求解

丶不离不弃

最近在测试类的大小的时候遇到了个问题，首先我介绍下我问题的由来，代码如下，相关注释已经附在代码中：

1. /*
   
2.         memory alignment issues
   
3.    0   1   2   3   4   5   6   7
   
4. 0        [ ] [ ] [ ] [ ]        [ ] [ ] [ ] [ ]
   
5. 8        [ ] [ ] [ ] [ ]        [ ] [ ] [ ] [ ]
   
6. 
   
7. 
   
8. */
   
9. 
   
10. //sizeof(A) = 32 bytes
    
11. 
    
12. class A {
    
13. private:
    
14.         uint32_t a; // 4 bytes
    
15.         uint8_t b; // 1 byte
    
16.         // insert 3 bytes of dead space
    
17.         double c;  // 8 bytes
    
18.         uint8_t d; // 1 byte
    
19.         // insert 7 bytes of dead space
    
20.         double e; // 8 bytes
    
21. public:
    
22. };
    
23. 
    
24. // write a class B to more efficiently pack
    
25. //sizeof(B) = 24 bytes
    
26. class B {
    
27. private:
    
28.         uint32_t a; // 4 bytes
    
29.         uint8_t b; // 1 byte
    
30.         uint8_t d; // 1 byte
    
31.         // insert 3 bytes of dead space
    
32.         double c;  // 8 bytes
    
33.         double e; // 8 bytes
    
34. public:

复制代码

此代码是为了求出一个类的大小，对齐原则就是按照最大的一个类型来对齐，但是我昨天在测试的时候发现了一个异常：
对于这段代码：

1. #include <iostream>
   
2. using namespace std;
   
3. class A{
   
4.     char a;//1
   
5.     uint32_t b;//4
   
6.     //insert 3 dead space
   
7.     char c;//1
   
8.     //insert 7 dead space
   
9.     double d;//8
   
10. };
    
11. struct B {
    
12.     double d;
    
13.     char a;
    
14.     int b;
    
15.     char c;
    
16. 
    
17. };
    
18. 
    
19. int main() {
    
20.     cout<< sizeof(A)<<endl;//24
    
21.     cout<< sizeof(B)<<endl;//24
    
22.     return 0;
    
23. }

复制代码

按照上面我理解的空间分配，应该是

1. char a;//1
   
2.     uint32_t b;//4
   
3.     char c;//1
   
4.     //insert 2 dead space
   
5.     double d;//8

复制代码

所以这样求出来的大小是16.。。。。。我的理解也是这样的
但是确是这样分配的：

1. char a;//1
   
2.     uint32_t b;//4
   
3.     //insert 3 dead space
   
4.     char c;//1
   
5.     //insert 7 dead space
   
6.     double d;//8

复制代码

请问哪位大神能告诉我这是为啥呢？难道char和int/uint32_t 在一起的时候分配是特殊情况吗？？？

人造人

1. class A{
   
2.     char a;//1
   
3.     uint32_t b;//4
   
4.     //insert 3 dead space
   
5.     char c;//1
   
6.     //insert 7 dead space
   
7.     double d;//8
   
8. };

复制代码

"对于简单类型，如int,char,float等，其对齐大小为其本身大小，即align(int) == sizeof(int)，align(char)==sizeof(char)，等等。"

a的offset是0
b的offset是4
c的offset是8
d的offset是16

参考
https://www.cnblogs.com/xylc/p/3780907.html

丶不离不弃

人造人 发表于 2019-12-8 10:34
"对于简单类型，如int,char,float等，其对齐大小为其本身大小，即align(int) == sizeof(int)，align(ch ...

我的意思是，double的大小是8，那么A类中的成员变量分配就是按8位单位来分，那么char, uint32_t,的大小分别为1byte和4byte，那么分配的时候不是应该按照如下：
第一个：char， 后4个：uint32_t， 最后1个：char
char     uint32_t  char
[] [] [] [] []  [] [] [] [] []    1+4+1+2死区
[] [] [] [] []  [] [] [] [] []    8
           double
第二排为double吗，我在按这个分配写算其他例子的时候都是对的，就是这个有问题
开始的char和uint32_t后面没分配完，第二个char为啥要单独独立出来占用8个字节呢？？

人造人

首先为变量a分配地址，变量a是一个char，align(char) == sizeof(char) == 1，当前可用地址是0，为变量a分配地址0，占用一个字节，下一个可用地址是1
然后为变量b分配地址，变量b是一个uint32_t, align(uint32_t) == sizeof(uint32_t) == 4，当前可用地址是1， 1不是4的倍数，向上对齐到4的倍数，得到的地址是4，地址1 2 3浪费掉，为变量b分配地址4，占用4个字节，下一个可用地址是8
然后为变量c分配地址，变量c是一个char，align(char) == sizeof(char) == 1，当前可以地址是8， 8是1的倍数，为变量c分配地址8，占用一个字节，下一个可用地址是9
然后为变量d分配地址，变量d是一个double，align(double) == sizeof(double) == 8，当前可用地址是9， 9不是8的倍数，向上对齐到8的倍数，得到的地址是16，地址9 10 11 12 13 14 15浪费掉，为变量d分配地址16，占用8个字节，下一个可用地址是24

整个结构体占用24个字节

人造人