//Self reference of structure: include a member whose type is the structure itself in the structure
struct Node
{
	int data;
	struct Node* Next;
};

typedef struct Node//The structure label node cannot be omitted
{
	int data;
	struct Node* Next;
} Node;

1.4 definition and initialization of structure variables

struct Point
{
	int x;
	int y;
}p3 = { 5,6 }, p4 = { 7,8 }; //Define variables P3 and P4 while declaring types

struct Point p2 = { 1,2 };//Initialization: define variables and assign initial values at the same time

struct S
{
	double d;
	struct Point p;//The structure contains the structure
	char name[20];
	char data[20];
};
int main()
{
	struct Point p1 = { 3,4 };
	struct S s = { 3.14,{3,4},"zhangsan",{1,2,3} };//Structure nesting initialization
	printf("%lf\n", s.d);
	printf("%d %d\n", s.p.x, s.p.y);
	printf("%s\n", s.name);
	int i = 0;
	for (i = 0;i < 20;i++)
	{
		printf("%d ",s.data[i]);
	}
	return 0;
}

1.5 structure memory alignment

Illustration:

//enumeration constant 
enum Color //Enumeration type
{
	Red,//Enumeration constant, whose size is fixed, is an integer variable with size bit 4B
	Green = 3,
	Blue
};

int main()
{
	//These enumeration constants start from 0 by default and increase by 1 at a time. They can also be given initial values when defined
	printf("%d\n",Red);//0
	printf("%d\n", Green);//3
	printf("%d\n", Blue);//4
	return 0;
}

//Usage:
enum Color 
{
	Red = 2,
	Green = 3,
	Blue = 5
};

int main()
{
	enum Color c = Green; //You can only assign values to enumeration variables with enumeration constants, so that there will be no type difference.
	
	if (c == Green)
	{
		printf("green\n");//green
	}
	return 0;
}

2, Enumeration

1.1 advantages of enumeration

We can use #define to define constants. Why do we have to use enumeration?

Advantages of enumeration:

1. Increase the readability and maintainability of the code

2. Compared with #define defined identifiers, enumeration has type checking, which is more rigorous

3. Prevent naming pollution (packaging)

4. Enumeration can be debugged, but #define cannot be seen during debugging

5. It is easy to use, and multiple constants can be defined at one time

1.2 use of enumeration constants

//Use of enumerated constants:
void menu()
{
	printf("*****************************\n");
	printf("****1.add  2.sub*************\n");
	printf("****3.mul  4. div************\n");
	printf("****0. exit    **************\n");
}
enum
{
	exit,//0
	add,//1
	sub,//2
	mul,//3
	div//4
};
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("Please select:>");
		
		scanf("%d", &input);
		switch (input)
		{
			case add: break;
			case sub: break;
			case mul: break;
			case div: break;
			case exit: break;
		}
	} while(input);
}

3, Consortium (Consortium)

1.1 characteristics of the Consortium

union Un
{
	char c;
	int i;
};
int main()
{
	union Un u = {0};
	printf("%d\n",sizeof(u));// 4
	printf("%p\n",&u); //012FFE8C
	printf("%p\n", &(u.c));// 012FFE8C
	printf("%p\n", &(u.i)); //012FFE8C
	return 0;
}

1.2} face to face questions

Determine the storage size of the current computer?

int main()
{
	int a = 1;

	//Writing method 1:
	//0x 00 00 00 01
	//01 00 00 small end storage
	//00 01 big end storage
	char* pc = (char*)&a;
	if (*pc == 1)
	{
		printf("Small end\n");//Small end
	}
	else
	{
		printf("Big end\n");
	}

	//Writing method 2: in the form of consortium, the same space is shared, but the two variables cannot be used at the same time
	union U
	{
		char c;
		int i;
	}u;
	u.i = 1;
	if (u.c == 1)
	{
		printf("Small end\n");//Small end
	}
	else
	{
		printf("Big end\n");
	}
	return 0;
}

1.3 calculation of consortium size

1. The size of the consortium shall be at least the size of the largest member

2. When the member size is not an integer multiple of the maximum alignment number, it should be aligned to an integer multiple of the maximum alignment number

int main()
{
	union Un1
	{
		char c[5];
		int i;
	};
	union Un2
	{
		short c[7];
		int i;
	};
	
	printf("%d\n", sizeof(union Un1)); //8
	printf("%d\n", sizeof(union Un2)); //16
}