C语言-自定义类型：结构体，枚举，联合

结构体

结构体的基础知识

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

结构体的声明

例如描述一个学生：

struct Stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
}S;//S为变量列表
typedef struct Stu
{
	int a;
	char b;
	float c;
}s,*p;//s,*p为类型

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

//匿名结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20],*p;

结构的自引用

1. 不使用typedef时
   错误的方式：

struct Node
{ 
  int data;
  struct Node next;//结构体
}; 

这种声明是错误的，因为这种声明实际上是一个无限循环，成员next是一个结构体，next的内部还会有成员是结构体，依次下去，无限循环。在分配内存的时候，由于无限嵌套，也无法确定这个结构体的长度，所以这种方式是非法的。
正确的自引用方式： （使用指针）：

struct Node
{ 
 int data;
 struct Node* next;//指针
}; 

由于指针的长度是确定的（在32位机器上指针长度为4），所以编译器能够确定该结构体的长度。

2. 使用typedef 时
   错误的方式：

typedef struct 
{ 
  int data;
  Node* next;//虽然也使用指针，但这里的问题是：Node尚未被定义 
} Node; 

这里的目的是使用typedef为结构体创建一个别名Node。但是这里是错误的，因为类型名的作用域是从语句的结尾开始，而在结构体内部是不能使用的，因为还没定义。
正确的方式：有三种，差别不大，使用哪种都可以。

/* 方法一 */ 
typedef struct Node
{ 
  int data; 
  struct Node* next;  
} Node; 
 
/* 方法二 */ 
struct tag_2; 
typedef struct tag_2 Node; 
struct tag_2
{ 
  int data; 
  Node* next;   
}; 
 
/* 方法三 */ 
struct tag_3
{ 
  int data; 
  struct tag* next;  
}; 
typedef struct tag_3 Node; 

结构体变量的定义和初始化

struct Point
{
	int x;
	int y;
}p1;//声明类型的同时定义变量p1
int main()
{
	struct Point p1;
	p1.x = 1;
	p1.y = 2;
	return 0;
}

struct stu
{
	char name[15];
	int age;
};
struct stu s = { "fandebiao", 45 };//初始化

struct Node
{
	int data;
	struct point p;
	struct Node* next;
}n1 = { 10, {4,5},NULL };//结构体嵌套初始化
struct Node n2={20,{5,6},NULL};//结构体嵌套初始化

结构体的使用

• 结构体可以使用 . 操作符来访问其成员
• 结构体的每个成员都是一个单独的变量，拥有单独的空间，可以单独的去修改
• 结构体中的数组在赋值时可以进行数组的一个一个元素赋值，也可以使用strcpy函数进行对字符数组赋值，千万不能使用 数组名=字符串 的方式。

介绍了以上结构体的使用规则，我举两个例子：

strcpy(student.name,"ningbo");
student.age = 20;
strcpy(student.sex,"female");

这里我将 student 结构体变量的所有成员的值都改了一下。
然后再介绍结构体的一种访问成员的方法：

• 结构体指针可以直接通过 -> 操作符来访问结构体的成员

首先得有一个结构体指针：

struct stu* pstudent; //定义一个struct stu型的指针
pstudent = &student; //将结构体student的地址放在结构体指针pstudent里面

然后再进行指针直接访问：

strcpy(pstudent->name,"liubei");
pstudent->age = 18;
strcpy(pstudent->sex,"male");

这里通过结构体指针pstudent将结构体student的成员又进行了修改。

结构体内存对齐

结构体的对齐规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   （对齐数= 编译器默认的一个对齐数 与 该成员大小的较小值。）

• VS中默认的值为8
• Linux中的默认值为4

3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所 有最大对齐数（含嵌套结构体的对齐数）的整数倍。

//求结构体的大小
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));//12
	printf("%d\n", sizeof(struct s2));//8
	printf("%d\n", sizeof(struct s3));//16
	printf("%d\n", sizeof(struct s4));//32
}

利用 #pragma 这个预处理命令，可以改变我们的默认对齐数。

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

总体来说：

• 结构体的内存对齐是拿空间来换取时间的做法。
• 设计结构体时，让占用空间小的成员尽量集中在一起。
• 结构在对齐方式不合适时，可以自己更改默认对齐数。

结构体传参

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

总结：

• 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
• 如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
• 结构体传参的时候，要传结构体的地址。

位段

位段的声明和结构体是很类似的，只是成员的类型有区别：

1. 位段的成员必须是 int, unsigned int 或 signed int。
2. 位段的成员名后边有一个冒号和一个数字，数字代表该成员所占的比特位（bit）。

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	printf("%d\n", sizeof(struct A));//8
	printf("%d\n", sizeof(struct S));//3
	return 0;
}

枚举

枚举顾名思义就是——列举，相当于创建一个自定义类型，用这个类型创建的变量只能取你自己设定的范围内的值，但这只是一个符号的定义，实际上都是 int 型的。

enum color
{
	red,
	green,
	blue,
};
enum color clr=green;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr=5;
int main()
{
	printf("%d\n", green);// 5
	return 0;
}

{}中的内容是枚举类型的可能取值，也叫 枚举常量。
枚举常量都是有值的，默认从0开始依次递增1，当然在定义的时候也可以赋初值。
枚举的优点

• 增加代码的可读性和可维护性
• 和#define定义的标识符比较枚举有类型检查，更加严谨。
• 防止了命名污染（封装）
• 便于调试
• 使用方便，一次可以定义多个常

联合体（共用体）

联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以 联合也叫共用体）

联合类型的声明

union Un
{
	char c;
	int i;
};

联合变量的定义

union Un un;

计算联合体变量的大小

int main()
{
	printf("%d\n", sizeof(un));//4
	return 0;
}

联合大小的计算

• 联合的大小至少是最大成员的大小。
• 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

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