C语言自定义类型详解

一、结构体

1.结构体类型的声明

结构体的基础知识
结构体是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
结构体的声明

struct tag//结构体名
{
    member-list;/成员变量列表
}variable-list;//结构体变量

如描述一个学生：

struct Stu
{
    char name[20];//名字
    int age;//年龄
    char sex[5];//性别
    char id[20];//学号
}；//分号不能丢

2.结构的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

struct Node
{
    int data;
    struct Node next;
};
//可行否？

答案当然是否！上述代码得操作是想进行结构体的自应用，但是采用的方式是不正确的，那么如何进行正确的自应用呢？
正确的自引用方式：

struct Node
{
    int data;
    struct Node* next;//以指针形式进行自引用
};

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

至此，我们知道了结构体类型这个概念，那如何用结构体定义变量呢？其实非常简单，有以下几种方式：

struct Point{
	int x;
	int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2

//初始化：定义变量的同时赋初值。
struct Point p3 = { x, y };
struct Stu{    //类型声明
	char name[15];//名字
	int age;    //年龄
};
struct Stu s = { "zhangsan", 20 };//初始化

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

4.结构体内存对齐

上述有关结构体的基础知识，都非常容易理解，接下来我们重点谈一个比较热门的问题：计算结构体的大小。
这个问题涉及到有关结构体的一个非常重要的知识点：结构体内存对齐。

//结构体1
struct S1{
	char c1;
	int i;
	char c2;
};
printf("%d\n", sizeof(struct S1));
//结构体2
struct S2{
	char c1;
	char c2;
	int i;
};
printf("%d\n", sizeof(struct S2));

我们先直接看结果：

从结构体1到结构体2成员变量并没有发生改变，只是放在结构体中的位置不同了，但结果我们却看到整个结构体的大小随之改变了，这是为什么呢？
聪明的读者肯定会立马想到，不是在讲结构体的内存对齐吗，肯定跟这个有关系，没错，出现上述结果正是因为结构体存在内存对齐的原因。
那究竟如何计算呢？首先我们就得掌握结构体内存对齐的规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   对齐数：系统默认的一个对齐数与该成员大小的较小值。（VS中的默认值为8，所以对齐数即可以理解为自身大小）
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

如果大家掌握了上述结构体内存对齐的规则，那么只需要再进行一些相关的计算练习，相信这个问题就再也难不倒大家了。接下来关于结构体的内存对齐还有最后一个问题，就是为什么存在内存对齐?
大部分的参考资料都是这样说的：

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

总结一下就是：
结构体的内存对齐是拿空间来换取时间的做法。

5.结构体传参

这个问题我们还是通过代码来展开：

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;
}

上述代码分别是结构体的传值传参和传址传参，哪个更好一些呢？
这里我们回顾一下曾经学过的数组传参，我们都知道数组在传参是会发生降维的，传进去的数组会降维成对应类型的指针，但是，区别就在这里，结构体传参时并不会发生降维，而是会进行数据的硬拷贝。
那么问题就来了，如果传进去的结构体过大，那在拷贝时是不是就会有很大的开销呢，这并不是我们想看到的，因此，我们在进行结构体传参时一般选择传址传参，也就是上述的print2函数。

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

结论：结构体传参的时候，要传结构体的地址。

二、枚举

枚举：顾名思义就是一一列举。把所有可能的取值或事物一一列举。
比如我们现实生活中：

一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举
颜色也可以一一列举。

当需要使用这种一一列举的情况时，枚举就派上了用场。

1.枚举类型的定义

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
};
enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};

以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。 {}中的内容是枚举类型的可能取值，也叫枚举常量 。
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。 例如：

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

2.枚举的优点

有的读者可能在看到枚举的特点时会想到宏这一概念，没错，不得不说枚举和宏定义常量在很多场合确实有一定的相似性，那我们既然可以使用宏（ #define）定义常量，为什么非要使用枚举呢？
这里我们就来谈谈枚举的优点：

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

3.枚举的使用

enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。

三、联合（共用体）

1.联合类型的定义

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

//联合类型的声明
union Un
{
	char c;
	int i;
};
//联合变量的定义
union Un un;
//计算联合变量的大小
printf("%d\n", sizeof(un));

2.联合的特点

union Un
{
	int i;
	char c;
};
union Un un;
// 下面输出的结果是一样的吗？
printf("%p\n", &(un.i));
printf("%p\n", &(un.c));
//下面输出的结果是什么？
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);

由于联合的特征是公用一块空间，所以上述代码的第一个问题答案自然是一样的，尽管是俩个不同的成员变量，但他们公用同一块内存，所以地址打出来也必定是相同的。
而在清楚联合的特点之后，我们也知道，对联合中任意一个成员的值进行修改是会影响其他成员的，那么上述代码的第二个问题正是考查这个知识。把un.c的值赋为0x55,un.i的结果会变成多少呢？由于c是char类型，所以它只能访问一个字节的位置，我们根据大小端的知识轻易得知，如果是小端模式，那么44的位置就会被修改为55，如果是大端模式，被修改的则是11的位置。因此，这个看似简单的代码就可以用来判断当前计算机的大小端存储。
代码运行结果：

从上述结果也能看出我的电脑所采用的是小端存储模式。

3.联合大小的计算

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

比如：

union Un1
{
	char c[5];
	int i;
};
union Un2
{
	short c[7];
	int i;
};
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));

直接揭晓答案：

由于上面已经了解过了结构体的内存对齐问题，所以相信上述结果大家都能理解，这里就不在赘述。

如果对于我这篇博客所总结的内容有任何疑问，欢迎大家在评论区与我交流。