关于struct的字节数计算（对齐）

struct MyStruct {
	double dda1; // 占8字节
    char dda; // 占1字节
    int type; // 占4字节
};

若按照我们的第一印象来计算那sizeof(Mystruct)的结果将是8 + 1 + 4 = 13字节，但是实际上你在vscode上跑一下就会知道结果输出将会是16，那么是为什么呢？原因就是编译器为了提高CPU的存储速度，会对变量的起始地址做了对齐处理。（在默认情况下，例如VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)）

类型	对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）
char	偏移量必须为sizeof(char)即1的倍数
int	偏移量必须为sizeof(int)即4的倍数
float	偏移量必须为sizeof(float)即4的倍数
double	偏移量必须为sizeof(double)即8的倍数
short	偏移量必须为sizeof(short)即2的倍数
long	偏移量必须为sizeof(long)即4的倍数
long long	偏移量必须为sizeof(long long)即8的倍数

• 各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。

1. 为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；
2. 接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；
3. 接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以sizeof(MyStruct)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

• 注意：不仅仅要按照“偏移量为类型倍数”这个原则，而且还要在每个元素分配完毕后，再检查“字节边界数”是否正确。有时因为大意导致此处少计算几个字节。如下例：

struct MyStruct {
    char dda; // 占1字节
    double dda1; // 占8字节
    int type; // 占4字节
};

sizeof(MyStruct) = 24为什么呢？首先先分配dda的空间为 1 个字节，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(char)的倍数；其次再分配dda1的空间，但是对于起始地址的偏移量为1 不是sizeof(double)的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充7个字节（这7个字节没有放什么东西)，然后把dda1放在偏移量为8的的地方；最后分配type的空间相对于起始偏移量为8 + 8 = 16 刚好是sizeof(int)的倍数，故把type放在偏移量为16的地方，16 + 4 = 20 (不是结构的字节边界数的倍数即结构中占用最大空间的类型所占用的字节数sizeof(double) = 8 的倍数)，故再填充 4 字节 = 24字节，所以此时sizeof(Mystruct) = 1 + 7 + 8 + 4 + 4 = 24字节 ，其中7 + 4 = 11 字节是没有任何意义的。

• VC中提供了 #pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。

  #pragma pack(push) //保存对齐状态
  #pragma pack(4)//设定为4字节对齐
  struct test{
  	 char m1;
  	 double m4;
  	 int  m3;
  };
  #pragma pack(pop)//恢复对齐状态
  // 1 + 4 + 8 + 4 = 16
  

  以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24（满足默认对齐方式）。

  #include <bits/stdc++.h>
  using namespace std;
  
  #pragma pack(4)
  struct MyStruct {
      char dda; // 占1字节
      double dda1; // 占8字节
      int type; // 占4字节
  };
  #pragma pack()
  
  int main() {
  	cout << "double dda1字节为 ：" << sizeof(MyStruct::dda1) << endl;
  	cout << "char dda字节为    ：" << sizeof(MyStruct::dda) << endl;
  	cout << "int type字节为    ：" <<  sizeof(MyStruct::type) << endl;
  	// 注意要考虑struct的对齐
      cout << "Mystruct的字节数为：" << sizeof(MyStruct) << endl;
  
      system("pause");
      return 0;
  }
  // 输出：
  	double dda1字节为 ：8
  	char dda字节为    ：1
  	int type字节为    ：4
  	Mystruct的字节数为：16
  

  修改 # pragam pack(1) （注意此处修改的必须是2^的整数倍，不然无法对齐）

  #include <bits/stdc++.h>
  using namespace std;
  
  #pragma pack(1)
  struct MyStruct {
      char dda; // 占1字节
      double dda1; // 占8字节
      int type; // 占4字节
  };
  #pragma pack()
  
  int main() {
  	cout << "double dda1字节为 ：" << sizeof(MyStruct::dda1) << endl;
  	cout << "char dda字节为    ：" << sizeof(MyStruct::dda) << endl;
  	cout << "int type字节为    ：" <<  sizeof(MyStruct::type) << endl;
  	// 注意要考虑struct的对齐
      cout << "Mystruct的字节数为：" << sizeof(MyStruct) << endl;
  
      system("pause");
      return 0;
  }
  // 输出：
  	double dda1字节为 ：8
  	char dda字节为    ：1
  	int type字节为    ：4
  	Mystruct的字节数为：13
  	
  //若设置为 # pragam pack(8)
      输出：
  		double dda1字节为 ：8
  		char dda字节为    ：1
  		int type字节为    ：4
  		Mystruct的字节数为：24
  

- 注：没有成员变量的结构或类的大小为1，因为必须保证结构或类的每一个实例在内存中都有唯一的地址

• sizeof的一些用法和以及各种类型的变量所占字节数

  Class Test {
      int a;
      static double c
  }; // sizeof(Test)=4.静态变量不会算入其中
  
  Test *s; // sizeof(s)=4,s为一个指针。
  
  Class test1{}; // sizeof(test1)=1;
  
  // 参数为其他， 这个地方一定要引起注意
  // sizeof(一维数组指针)返回的是数组单个元素指针的大小，即系统指针的长度，32位系统为4，64位系统位8
  // sizeof(*一维数组指针)返回的是数组单个元素对应类型的大小
  // sizeof(二维数组指针)返回的是二维数组行指针的大小，32位系统为行数×4，64位系统位行数×8
  // sizeof(*二维数组指针)返回的是系统指针的长度，32位系统为4，64位系统位8
  // sizeof(**二维数组指针)返回的是数组单个元素指针的大小
  // 在C/C++里数组作为参数时传递的实际上是指向数组第一个元素的指针，因此sizeof(str)返回的是指针的大小，即32位为 4   64位为 8
  int func(char s[5]) {
      cout << sizeof(s); 
      //这里将输出4，本来s为一个数组，但由于做为函
      //数的参数在传递的时候系统处理为一个指针，所
      //以sizeof(s)实际上为求指针的大小。
      return 1;
  }
  
  sizeof(func(“1234”)) = 4 //因为func的返回类型为int，所以相当于 //求sizeof(int).
  

• C/C++ 中不同目标平台下各数据类型长度是不同的，数据类型的实际长度由编译器在编译期间通过编译参数指定目标平台而确定的。 short int，int，long int 的字节数都是随编译器指定的目标平台而异，但是在ANSI/ISO指定：

  sizeof(short int) <= sizeof(int);
  sizeof(int) <= sizeof(long int);
  short int >= 16 bit (2 Byte);
  long int >= 32 bit (4 Byte).
  

  类型	char	short int	int	unsigned int	float	double	long	long long	unsigned long	指针
  16位编译器	1	2	2	2	4	8	4	8	4	2
  32位编译器	1	2	4	4	4	8	4	8	4	4
  64位编译器	1	2	4	4	4	8	8	8	8	8

  • 指针变量所占字节数是根据编译器的寻址空间决定宽度的：
    16 bit编译器寻址空间为16 bit，所以指针变量宽度为2 Byte;
    32 bit编译器寻址空间为32 bit，所以指针变量宽度为4 Byte;
    64 bit编译器寻址空间为64 bit，所以指针变量宽度为8 Byte.

• 参考链接
  https://www.cnblogs.com/qiu0130/articles/3824120.html
  https://zhuanlan.zhihu.com/p/93583960

• 补充：嵌套类型（含结构体成员）

  /**
   *  规则一：结构体中的第一个成员位置在偏移量0，之后每个变量的偏移量必须是它本身字节数的整数倍。
  
   *  规则二：如果结构体中嵌套结构体，那么嵌套的结构体的偏移量必须是它最大成员的字节数的整数倍。
  
   * ★规则三：结构体的总偏移量必须是它最大成员字节数的整数倍（包括嵌套的结构体中的最大成员）。★
  
   * 如果一个结构体B里嵌套另一个结构体A，还是以最大成员类型的字节对齐，但是结构体A存储起点为A内部最大成员整数倍的地方。
   * （struct B里存有struct A，A里有char，int，double等成员，那A应该从8的整数倍开始存储。）
   *  结构体A中的成员的对齐规则仍满足自身的规则 
   * 注意： 
      1）结构体 A 整体所占的大小为该结构体成员内部最大元素的整数倍，不足补齐。 
      2）不是直接将结构体 A 的成员直接移动到结构体 B 中。
  */
  #include <bits/stdc++.h>
  
  using namespace std;
  
  struct test1{
  	 char m1;
  	 double m4;
  	 int  m3;
  }; // 1 + 7 + 8  + 4 = 20 + 4 = 24
  
  struct test2{
  	 char m1;
  	 double m4; // 若改为int 则为1 + 3 + 4 = 8 + 24 = 32 刚好是8 字节的倍数，因为test1的最大字节为8，故sizeof(test2)为32
  	 struct test1 test; 
  }; // 1 + 7 + 8 = 16 + 24 = 40 为什么不对齐？
     // 对齐了因为结构体test2 是以double字节对齐的（最大）与结构体成员test1的整体大小无关 40 刚好是8 的倍数
  
  /*
  struct test2{
  	 char m1;  //1 + 1 + 1 + 1 + 1 + 3 + 4 = 12 + 24 = 36 + 4 == 40 恰好为double字节的倍数
       char m2;
       char m3;
       char m4;
       char m5;
  	 int m6;  
  	 struct test1 test; 
  };
  */
  int main() {
      cout << sizeof(test1) << endl; // 24 
      cout << sizeof(test2); // 40
  
      system("pause");
      return 0;
  }