How to calculate the size of structure, segment and Consortium (common body)

How to calculate the size of the structure .

        If you want to calculate the size of the structure , We must know the concept of memory alignment of structures , Here are some elements of memory alignment of structures ：

1. The first structure member is offset from the structure variable by 0 The address of .

2. The remaining Other member variables are aligned to a number （ Align numbers ） An integral multiple of the address of .

    Align numbers Namely Compiler default alignment number And The size of the member Smaller value .

    stay VS The default value in is 8.

3. The total size of the structure is the maximum number of alignments （ Each member variable has an alignment number ） Integer multiple .

#include<stdio.h>
struct S1
{
	char c1;//1 Bytes 
	int i;//4 Bytes 
	char c2;//1 Bytes 
};

struct S2
{
	char c1;//1 Bytes 
	char c2;//1 Bytes 
	int i;//4 Bytes 
};
int main()
{
	printf("%d\n", sizeof(struct S1));//12
	printf("%d\n", sizeof(struct S2));//8
	return 0;
}

Let's see how we got this result ？

  Later, we run the code to see whether it is consistent with our analysis ,

  How to calculate the size of the bit segment .

#include<stdio.h>
struct A 
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
int main()
{
	printf("%d\n", sizeof(struct A));//8
	return 0;
}

If struct A If it's not a bit segment, we know 4 The size of a plastic is 16, How did this code get 8 What about the size ？

Let's first understand how the memory of the lower segment is allocated

1. The members of a segment can be int unsigned int signed int Or is it char （ It belongs to the plastic family ） Type of .

2. The space of the bit segment is based on 4 Bytes （ int ） perhaps 1 Bytes （ char ） The way to open up .

  Let's run the code to verify , because Bit segments involve many uncertainties , Bit segments are not cross platform , Pay attention to portable program should avoid using bit segment .

  Consortium ( Shared body ) How to calculate the size of .

#include<stdio.h>
union S1
{
	char c;
	int i;
};
int main()
{
	union S1 s;
	printf("%d\n", sizeof(s));//4
	return 0;
}

Let's first look at the joint memory calculation rules ：

Memory computing rules ：

1. The size of the union is at least the size of the largest member ,( Because the union must at least have space to save the largest member )

2. When the maximum member size is not an integral multiple of the maximum number of alignments , It's about aligning to an integer multiple of the maximum number of alignments .