【C语言】自定义类型（结构体-枚举-联合）

---

一、结构体

    1.1 结构体基础知识

            定义：结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

    1.2 结构的声明

            语法：

struct tag
{
member-list;
}variable-list;//variable-list可以省略

    1.3 特殊声明

   在声明结构的时候，可以不完全的声明

//匿名结构体类型
struct
{
int a;
char b;
float c;
}x;

🔵特点：只能用一次。
🔴注意：

struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], * p;
int main()
{
	//p = &x;//err 编译器会将两个声明视为不同的类型
	return 0;
}

    1.4 结构的自引用

    结构体内部如果还定义了同类型结构体 ，那么sizeof(结构体)的数值会无限大。为了解决上述问题，我们可以定义同类型结构体的指针。

struct Node//节点
{
	int data;//数据域
	struct Node* next;//指针域
};

🔴注意：结构体自引用时候不要匿名

typedef struct
{
	int data;
	//Node* next;//err 匿名结构体重命名之后才叫Node，而在声明中用Node显然不对
}Node;

    1.5 结构体变量的定义和初始化以及访问

struct book
{
	char name[20];
	char author[20];
	int price;
}b1 = { "xxx","xxx",12 };//全局变量的创建和初始化

struct book b2 = { "xxx","xxx",12 };//全局变量的创建和初始化
//结构体内有结构体
struct S
{
	int x;
	struct book b4;
};
int main()
{
	struct book b3 = { "xxx","xxx",12 };//局部变量的创建和初始化
	struct S s = { 1,{"xxx","xxx",12} };//结构体内有结构体的创建和初始化
	printf("%d\n", b1.price);
	printf("%s\n", s.b4.author);
	return 0;
}

    1.6 结构体内存对齐

struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};
struct S3
{
	double d;
	char c;
	int i;
};
//结构体嵌套问题
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{
	printf("%d\n", sizeof(struct S1));//？
	printf("%d\n", sizeof(struct S2));//？
	printf("%d\n", sizeof(struct S3));//？
	printf("%d\n", sizeof(struct S4));//？
}

结构体内存对齐的规则：
①结构体的第一个成员永远放在结构体起始位置偏移量为0的位置。
②结构体成员从第二个成员开始，总是放在偏移量为一个对齐数的整数倍处。（对齐数：编译器默认对齐数与变量自身大小的较小值，Linux中无默认对齐数，VS中默认对齐数为8）
③结构体的总大小必须是各个成员的对齐数中最大的那个对齐数的整数倍。
④存在嵌套，如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

🔴注意：结构体类型的声明不占用内存空间，只有创建变量后开辟内存空间。、

❗ 为什么存在内存对齐：
✅
      ①平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
      ②性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总结：结构体的内存对齐是拿空间来换取时间。
因此设计结构体的时候既要满足对齐，又要节省空间，让占用空间小的成员尽量集中在一起。

    1.7 修改默认对齐数

    结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。#pragma 这个预处理指令可以改变我们的默认对齐数。

#pragma pack(8)//设置默认对齐数为8
struct S1
{
	char c1;// 1 8 1
	int i;  // 4 8 4
	char c2;// 1 8 1
}s1;
#pragma pack()//取消设置的默认对齐数，还原为默认(VS下默认为8)

#pragma pack(1)//设置默认对齐数为1
struct S2
{
	char c1;//1 1 1
	int i;  //4 1 1
	char c2;//1 1 1
}s2;
#pragma pack()//取消设置的默认对齐数，还原为默认

int main()
{
	printf("%d\n", sizeof(s1));//12
	printf("%d", sizeof(s2));//6
}

[ 补充阅读 ]：offsetof宏的实现:计算结构体中某变量相对于首地址的偏移

    1.8 结构体传参

    两种方法传：①传结构体 ②传地址

struct S
{
	int data[1000];
	int num;
};
struct S s = { {1,2,3,4}, 1000 };
//结构体传参
void print1(struct S s)
{
	for (int i = 0; i < 4; i++)
	{
		printf("%d", s.data[i]);
	}
	printf("\n");
	printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
	for (int i = 0; i < 4; i++)
	{
		printf("%d", ps->data[i]);
	}
	printf("\n");
	printf("%d\n", ps->num);
}
int main()
{
	print1(s);  //传结构体
	print2(&s); //传地址
	return 0;
}

🔴注意：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
   如果传递一个结构体对象的时候，结构体过大，所以会导致性能的下降。所以最好采用传地址的方式。
   如果害怕指针将结构体内部的数据修改那么解决方法可以用const加以保护

//结构体地址传参加const保护
void print2(const struct S* ps)
{
	for (int i = 0; i < 4; i++)
	{
		printf("%d", ps->data[i]);
	}
	printf("\n");
	printf("%d\n", ps->num);
}

二、枚举

    2.1 枚举类型的定义

🔵特点：
    ① { }内是常量，称为枚举常量
（常量有：const修饰的常变量，#define定义的标识符常量，枚举常量）
    ② 默认从0开始，依次递增1

enum Day//星期
{
	Mon, //注意！尾部是 ，
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
int main()
{
	printf("%d\n", Mon);//0
	printf("%d\n", Tues);//1
	return 0;
}

//赋值
enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};
int main()
{

	printf("%d\n", RED);//1
	printf("%d\n", BLUE);//4
}

    2.2 枚举的优点

    ① 增加代码的可读性和可维护性
    ② 和#define定义的标识符比较枚举有类型检查，更加严谨。#define是直接替换，而枚举有所保留。
    ③ 防止了命名污染（封装）
    ④ 使用方便，一次可以定义多个常量

    2.3 枚举的使用

enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};
int main()
{	
	//c++中认为不能enum与int类型不匹配
	// 
	//enum Color c1 = 2;
	//if (c1 == GREEN)
	//{
	//	printf("绿色");
	//}

	enum Color c2 = GREEN;
	if (c2 == GREEN)
	{
		printf("绿色");
	}
}

三、联合

    3.1 联合类型的定义

🔵特点：成员公用同一块空间

//联合类型的声明
union Un
{
	char c;//1
	int i;//4
};
//联合变量的定义
union Un un;

//验证共用空间
int main()
{
	printf("%p\n", &un);       //000DA13C
	printf("%p\n", &(un.c));   //000DA13C
	printf("%p\n", &(un.i));   //000DA13C
}

    3.2 联合体测试大小端

其他测试方法

int check()
{
	union  UN
	{
		int i;
		char c;
	}un;
	un.i = 1;
	return un.c;
}
int main()
{
	if (1 == check())
	{
		printf("小端存储模式");
	}
	else
	{
		printf("大端存储模式");
	}
}

    3.3 联合大小的计算

联合大小的计算规则：
① 联合的成员是共用同一块内存空间的，所以一个联合变量的大小，至少是最大成员的大小。
②当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

//eg1
union Un
{
	char c;//1 8 1
	int i; //4 8 4
};
union Un un;
int main()
{
	printf("%d\n", sizeof(un));//4
}

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

---

[ 补充阅读 ]：位段