Structure size

1、 The size of the structure is formed by adding the member variables and offsets ;
2、 Other member variables are aligned to a number （ Align numbers ） An integral multiple of the address of , The overall size should also be divisible by the aligned number

Total alignment ： = The compiler defaults to an alignment number and the smaller value of the member size , That is to say min{ The compiler's default number of alignments , The maximum size of the member variable },VS The default alignment number in is 8;

Number of individual alignments : The memory occupied by variables of this type ,char The alignment number is 1 ,int The alignment number is 4 , double yes 8 , 32 The bit pointer type is 4 , 64 The bit pointer type is 8;

The alignment principle is divided into two steps ：

1、 Single member variable alignment （ in other words , The starting address of a single variable can be divided by a single aligned number ）
2、 Overall alignment （ The overall size can be divided by the aligned number , If it can't be divided completely , Then increase the offset to fill ）

Same member variable , Because the declaration position is different , As a result, the occupied memory space is different , Look at the code below

void test6()
{
    
// Total alignment min{ The compiler's default number of alignments =8 , The maximum size of the member variable double=8 } = 8
	struct node
	{
    
		// Suppose the total space is all 
		double m;//8 double The alignment number is 8 , here all=8 [0:7]
		int a;//4 int  The alignment number is  4 all=12 [8:11]
		char c;//1 char Align numbers  1 all=13 [12]
		char b;//1 char Align numbers  1 all=14 [13]
	};//16 ** Start overall alignment , It should be divisible by the whole alignment number , That is, it can be 8 to be divisible by ,14 Can not be 8 to be divisible by ,+2=16  that will do , therefore all=16**

	struct node1
	{
    
		char c;		//1 char Align numbers  1 all=1
		int a;//4 int Align numbers  4 (char c  Three bytes are left after , Store from the fourth byte  int a) all=8
		char b;			//1 char Align numbers  1 all=9
		double m;//8 double The alignment number is 8 (char b  Rear empty 7 Bytes , Store from the fourth byte double m) , here all=24
	};//24 24 Can be 8 to be divisible by , So the whole does not need to be offset 

	cout << sizeof(node) << "---" << sizeof(node1) << endl;
}

Single member variable alignment （ in other words , The starting address of a single variable can be divided by a single aligned number ） More generally speaking, it is ;double Type must be from 8 The divisible address begins ,int Must be 4 The divisible address begins , If the starting address cannot be divisible , Then move backward , Until it can be divided , The empty space is directly wasted , Trade space for time .

If the structure is nested , The inner nested structure member is aligned to the address of an integer multiple of its maximum alignment number , The overall size of the structure is the maximum number of alignments （ The number of alignments with nested structures ） Integer multiple .

Why offset
The reason for the platform （ Reasons for transplantation ）： Not all hardware platforms can access any data on any address ; Some hardware platforms can only get certain types of data at certain addresses , Otherwise, a hardware exception will be thrown .
Performance reasons ： data structure （ Especially stacks ） It should be aligned on the natural boundary as much as possible . The reason lies in , To access unaligned memory , The processor needs to make two memory accesses ; The aligned memory access only needs one access .