C language: custom type

One 、 Structure

1. Definition and initialization of structure variables

Go straight to the code ：

struct Point {
    
	int x;
	int y;
}p1;     // Create variables when creating structures , The semicolon must not fall 

struct Point p2;    // Create variables separately 
struct Point p3 = {
     1,2 };   // Assign values when creating variables 

struct Node {
    
	char str[20];
	struct Point p;     // Nested structure 
}n1 = {
     "abcd",{
    3,4} };

int main() {
    
	printf("%s\n", n1.str);   // Structure access , use . perhaps ->, Variable access is used ., For pointer access ->
	printf("%d\n", n1.p.x);
	printf("%d\n", n1.p.y);
	return 0;
}

struct Is the keyword for creating a structure ,Point Is the name of the structure ,p1 It's a structure Point A variable of ,x,y Called structure Point Member variables in , There are two forms of variable creation , First of all , You can create it together when you create a structure , second , Create... Separately , Create rules of type + name , Assignment to structure , You can assign values when creating variables , You can create variables first and then assign values separately . There are two ways to access structures , When accessing with variables , use .（ spot ）, Then select the attribute corresponding to the variable ; When accessing with pointers , use ->, Then select the corresponding attribute .

2. Structure memory alignment

When we want to calculate the memory size of the structure , You need to know the concept of structure diagram memory alignment , Let's start with two examples ：

struct A {
    
	char a;
	char b;
	int c;
};

struct B {
    
	char a;
	int c;
	char b;
};

int main(){
    
	printf("%d\n", sizeof(struct A));
	printf("%d\n", sizeof(struct B));
	return 0;
}

It turns out that ,A and B The memory size occupied by the two structures is not equal , But its internal member variables are the same , It's just in a different order . The reason for the different results is memory alignment , Let's introduce the rules of structure memory alignment ：

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

2. Other member variables are aligned to a number （ Align numbers ） An integral multiple of the address of . Align numbers = Compiler default alignment number And The smaller value of the member size . stay VS In the compiler , The default number of alignments is 8.

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

4. If the structure is nested , The nested structure is aligned to an integral multiple of its maximum alignment , The integrity of the structure Body size is the maximum number of alignments （ The number of alignments with nested structures ） Integer multiple .

3. Why memory alignment ？

From the above results, we can probably guess , To save space . in general , There are two main reasons ：

1. Platform reasons ：

   Some hardware platforms can only get addresses at specific addresses , No memory alignment , There may be errors when taking values .

2. Performance reasons ：

   For misalignment , It may take two times to read the data , The following is an example ：

In a 32 A platform , In case of misalignment , If you want to read int Of 4 Bytes , For the first time, I will read char One byte of , and int After 3 Bytes （ The small end ）, Need to read again , Only then int Of 4 Bytes are completely read ; By comparison , If it is in the case of memory alignment , You only need to read once to put int Of 4 Read it directly .

Two 、 Bit segment

The structure also has the ability to implement bit segments , The problem is coming. , What is a bit segment ？

1. What is a bit segment

The declaration of bit segments and structs are similar , But there are two differences ：

• The member of the segment must be int、unsigned int or signed int .
• The member name of the segment is followed by a colon and a number .

for example ：

struct A
{
    
 int _a:2;
 int _b:5;
 int _c:3;
 int _d:4;
};

A It's a bit segment type , Want to know A Size , It can also be used sizeof Come and ask for .

2. Bit segment memory allocation

Take the bit segment above A Come on , Will first open a in memory 4 Byte space , The number after the colon indicates the memory size of the member variable , Unit is bit, The members in the bit segment are allocated from left to right in memory , When a structure contains two bit segments , The second segment is relatively large , Cannot hold the remaining bits of the first bit segment , yes Discard the remaining bits or use , This is uncertain . in general , Compared to the structure , Bit segments can achieve the same effect , But it can save a lot of space , But there are cross platform problems . It's not easy to understand just talking , Let's look at the picture below ：

Of course , Bit segments save more memory than structures , But it has cross platform problems , It needs to be used with caution .

3、 ... and 、 enumeration

1. Definition of enumeration

enum Day// week 
{
    
 Mon,  // By default Mon The value is 0, The values of the following member variables increase in turn 
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};

Of course, you can also assign values when defining , for example ：

enum Color// Color 
{
    
 RED=1,
 GREEN=2,
 BLUE=4
};

2. Advantages of enumeration

We know ,#define You can define constants , Then why use enumeration ？

Advantages of enumeration ：

1. Increase the readability and maintainability of the code
2. and #define The defined identifier comparison enumeration has type checking , More rigorous .
3. Easy to use , You can define more than one constant at a time

Since it exists , There is a reason for its existence , Sometimes #define More convenient , Sometimes enumeration is more convenient , We should learn to use reasonably

Four 、 union （ Shared body ）

1. Definition of joint type

union Un  // Statement 
{
    
 char c;
 int i;
};
union Un un;  // Defining variables 
printf("%d\n", sizeof(un));  // Calculate the size of the community 

2. Characteristics of Union

Members of the union share the same memory space , The size of such a joint variable , At least the size of the largest member （ because The union must at least be able to preserve the largest member ）.

union Un
{
 int i;
 char c;
};
union Un un;
//  Is the result of the following output the same ？
printf("%d\n", &(un.i));
printf("%d\n", &(un.c));
// What is the output below ？
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);

It can be seen from the results ,i and c The address of is the same , Because they share a space , When given separately i、c assignment , After assignment c Will cover before i Part of the value of .

3. Calculation of joint size

• The size of the union is at least the size of the largest member .
• 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 .

for example ：

union Un1
{
    
 char c[5];
 int i;
};
union Un2
{
    
 short c[7];
 int i;
};
// What is the output below ？
printf("%d\n", sizeof(union Un1));  //8,c Occupy 5 Bytes , Than i Big , Maximum alignment digit 4, Need to be for 4 Multiple , So for 8
printf("%d\n", sizeof(union Un2));  //16,c Occupy 14 Bytes , The maximum number of alignments is 4, So for 16