【C/C++】内存对齐

在了解内存对齐方式前，先介绍计算机的存储方式：Big Endian与Little Endian：

• Big Endian: 即数据的高位在低地址，地位在高地址，并且把最高字节的地址作为变量的首地址

• Little Endian: 即数据的高位在高地址，数据的低位在低地址，并且把最低字节的地址作为变量首地址。

现实中，某些基于RISC(精简指令集)的cpu比如SPARC、PowerPC等，采用Big Endian，而Intel系列cpu采用Little Endian。如果想要知道自己的电脑是什么存储格式只需要输入以下代码：

#include<iostream>

using namespace std;

void main()
{
	 char ch[]={0x12,0x34,0x56,0x78};
	 int* p=(int*)ch;
	 cout<<hex<<*p<<endl;//如果是78563412，说明是 Little Endian,如果是12345678，则是Big Endian
}

自然对齐：如果一个变量的内存地址正好位于它字节长度的整数倍，它就被称做自然对齐

​ 对于标准数据类型，它的地址只要是它的长度的整数倍，而非标准数据类型按下面的原则对齐：
　- 数组 ：按照基本数据类型对齐，只要第一个对齐后面的自然也就对齐。
　- 联合 ：按其包含的长度最大的数据类型对齐。
　- 结构体： 结构体中每个数据类型都要对齐。

字节对齐的好处：
　 字节对齐的根本原因在于CPU访问数据的效率问题。学过微机原理的都知道规则字和非规则字，8086cpu访问规则字只要一个周期，而访问非规则字需要两个周期。在这里原理也是一样的，只不过这里是32位的操作系统，最多一次访问4字节，而8086是16位的，一次最多访问2字节。假设上面整型变量的地址是自然对齐，比如为0x00000000，则CPU如果取它的值的话需要访问一次内存，一次直接取从0x00000000-0x00000003的一个int型，如果变量在0x00000001，则第一次访问0x00000001的char型，第二次取从0x00000002-0x00000003的short型，第三次是0x00000004的char型，然后组合得到所要的数据，如果变量在0x00000002地址上的话则要访问两次内存，第一次为short，第二次为short，然后组合得到整型数据。如果变量在0x00000003地址上的话，则与在 0x00000001类似。

我们通过下面的例子来说明自然对齐：

#include<iostream>

using namespace std;

void main()
{
	int a=0x0abcde11;//a b c 的地址依次减小
	int b=0x012345678;
	double c=0x0f23456789abcdef1;
    char d=0x0fa;

   	char *ptr=(char*)&a;
    printf("a b每个字节的内容：\n");
	printf("  地址  :内容\n");
	for(int i=0;i<8;i++)
		printf("%x  :%x\n",ptr+3-i,*(ptr+3-i));//说明整数是按 little-endian存储的


    printf("\na b c d的首地址和地址与字节长度的余值：\n");
	printf("a: %x :%d\n",&a,long(&a)%sizeof(a));//从这里可以看成变量的内存地址按变量顺序递减的 
	printf("b: %x :%d\n",&b,long(&b)%sizeof(b));//各个变量并不一定存放在连续的内存单元
	printf("c: %x :%d\n",&c,long(&c)%sizeof(c));
	printf("d: %x :%d\n",&d,long(&d)%sizeof(d));
}

上面程序在我电脑的运行结果为：

由上面的结果可以知道：

• 地址随变量顺序而减小（你可以通过改变变量定义顺序来测试）；
• 我的电脑采用的是Little Endian；
• 各个变量并不一定存放在连续的内存单元（由c d的地址可知）

对于数组，无论是静态数组还是动态数组都是连续存储的，可以用下面程序来查看：

#include<iostream>

using namespace std;

void main()
{
    int array[5]={0};
	for(int i=0;i<5;i++)
	cout<<&array[i]<<endl;//输出静态数组的每个元素的地址
    cout<<endl;

	int *pt=new int[5];
	for( i=0;i<5;i++)
	cout<<hex<<(pt+i)<<endl;//输出动态数组的每个元素的地址
    cout<<endl;

	delete []pt;//注意要释放内存
    
}

---

上面我们讨论了基本数据类型的内存存储，下面我们来看看类的存储结构。首先我们看看下面这个类：

class person1
	{
		bool m_isMan;
		float m_height;
		bool m_isFat;
		double m_weight;
		unsigned char m_books;
	};
	cout<<sizeof(person1)<<endl;//32=4+4+8+8+8

这里person类的长度为32，其内存单元示意图如下：

在这里是按8字节边界来对齐的。上述变量已经都自然对齐了，为什么person对象最后还要填充7字节？因为当你定义person类型的数组时，如果不填充7字节，则除了第一个元素外其它的元素就可能不是自然对齐了。

下面通过使用编译指令来定义对齐方式：

#pragma pack(push,4)// 按4字节边界对齐
	class person2
	{
		bool m_isMan;
		float m_height;
		bool m_isFat;
		double m_weight;
		unsigned char m_books;
	};
	cout<<sizeof(person2)<<endl;//24=4+4+4+8+4
#pragma pack(pop)

这里person类的长度为24，其内存单元示意图如下：

显然，在这里m_weight的地址不一定能被8整除，即不一定是自然对齐的。

从上面可以知道，内存的大小和存取的效率随编译方式和变量定义有关，最好的方法是：按照字节大小从大到小依次定义变量成员，并尽可能采用小的成员对齐方式。

• 从小到大定义变量：

  //按照从小到大字节长度来定义变量
  	class person4
  	{
  		bool m_isMan;
  		bool m_isFat;
  		unsigned char m_books;
  		float m_height;
  		double m_weight;
  	};
  	cout<<sizeof(person4)<<endl;//16=1+1+1+1字节的填充+4+8

  这里person类的长度为16，其内存单元示意图如下：

  

• 从大到小定义变量：

  //按照从大到小字节长度来定义变量
  	class person3
  	{
  		double m_weight;
  		float m_height;
  		unsigned char m_books;
  		bool m_isMan;
  		bool m_isFat;
  	};
  	cout<<sizeof(person3)<<endl;//16=8+4+1+1+1+1字节的填充

  这里person类的长度为16，其内存单元示意图如下：

  

​ 从上面可以看出两者所占内存一样，但是稳定度不同，从小到大的方式的对齐方式而发生有的成员变量不会自然对齐。如下所示

 #pragma pack(push,1)// 按4字节边界对齐
	class person5
	{
		bool m_isMan;
		bool m_isFat;
		unsigned char m_books;
 		float m_height;
  		double m_weight;
	};
	cout<<sizeof(person5)<<endl;//15=1+1+1+4+8
#pragma pack(pop)

这里person类的长度为15，其内存单元示意图如下：

在上面的程序中，double的偏移量为1+1+1+4=7，很有可能不会自然对齐,所以最好采用从大到小的方式来定义成员变量。

​