【C语言】自定义类型

Hello!各位小伙伴好久不见啊，有没有想小编呢？本期小编会带领大家深入了解自定义类型，希望对各位小伙伴有所帮助哦！

---

前言 1、为什么要有自定义类型

在C语言中就存在这种int,char,short,long ,long long,float,double等等类型，那为什么要有自定义类型呢？

因为在我们的现实生活中存在着复杂对象，比如说人，有性别、年龄等等等等数据，所以为了更加方便解决复杂问题就产生了自定义类型，让我们自己定义解决问题，这样会十分简洁方便。

前言 2、自定义类型有哪一些

1、结构体
2、枚举
3、联合体

接下来我们按着是三种类型顺序来讲

一、结构体

1、结构体与数组的区别

数组是一种相同类型数据的集合，它的数据类型都是相同的
结构体类型则是值的集合，这些值被称为成员变量。这些成员变量可以是不同类型的值

2、结构体类型的声明

A、声明方法1

struct str
{
	char name[20];
	int age;
	//......
};

这就是一个最简单的结构体类型声明

注意

以上代码只是一个声明，该代码的作用等同于int，float这样的类型

B、声明方法2

struct str
{
	char name[20];
	int age;
	//......
}s1,s2;

上面的s1和s2都是根据struct str结构体创建出来的结构体变量

注意

struct str
{
	char name[20];
	int age;
	//......
}s1,s2;
int main()
{
	struct str
	{
		char name[20];
		int age;
		//......
	}s3,s4;
	struct str s5;
	return 0;
}

1、这里的s1和s2是在main函数外面创建的，所以s1和s2是全局结构体变量

2、而s3、s4和s5是在main函数里里面创建的，所以s1和s2是全局结构体变量

C、特殊声明

匿名结构体类型：

struct 
{
	char name[20];
	int age;
	//......
}s1;

这里的结构体关键字struct后面什么都没有就是匿名结构体，什么叫匿名结构体呢？
就是说，这个结构体只能使用一次就不能够再使用了，也就是s1只能用一次，就不能够再被使用了。因为struct后面没有名字了，我们不能够再使用

样例

//匿名结构体类型
struct
{
  int a;
  char b;
  float c;
}x;
struct
{
  int a;
  char b;
  float c;
}a[20], *p;
int main()
{
	p = &x;
	return 0;
}

大家看，这里会报警告，说两个类型不兼容，为什么呢？

虽然两者类型一模一样，但是编译器会把它们当作不同的两种类型来看待，所以会报警告

3、结构体的自引用

结构体的自引用和数据结构的链表有着异曲同工之妙；

错误的自引用：

//代码1
struct Node
{
 int data;
 struct Node next;
};
//可行否？
如果可以，那sizeof(struct Node)是多少？

这里一个struct Node里面有一个data，4个字节，还有一个next结构体；这个next结构体里面又有一个int，4个字节，又有一个next结构体，而一直这样next结构体自引用下去会开辟无数个字节空间大小，因为我们停不下来，没有停止的条件

这个时候就要用到链表的知识了：

链表里面数据是分散在各地的，所以为了方便正确的找到各项数据，每个节点的分为两部分：一部分叫做数据域，是用来存放我们要找的数据的；另一部分叫做指针域，用来存放我们要找的下一个元素的地址。这样才能够准确找到每一个元素。

同理

结构体的自引用就要用到这种方法：

//代码2
struct Node
{
 int data;
 struct Node* next;
};

两个变量，一个变量是数据，一个变量是指针；这个结构体指针能够找到同类型的节点，这样才叫做结构体的自引用

知识点

//代码3
typedef struct
{
 int data;
 Node* next;
}Node;
//这样写代码，可行否？

注意：这样的方法是绝对不允许的，匿名结构体只能使用一次，现在用typedef重定义匿名结构体，那么这个Node是匿名结构体成员变量呢？还是typedef重定义出来的呢？这就是一个先有鸡还是先有蛋的问题，我们谁的说服不了谁。所以，严禁这样写代码。

//解决方案：
typedef struct Node
{
 int data;
 struct Node* next;
}Node;

这样写代码才是正确的

typedef struct Node
{
	int data;
	struct Node* next;
}* linklist;

//2
struct Node
{
	int data;
	struct Node* next;
};
typedef struct Node* linklist;

上面两种重命名效果是一样的，只不过第一种更简单一点

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

A、定义

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


struct Point p2; //定义结构体变量p2

上面两种定义是一样的，都是可以的

B、初始化

//初始化：定义变量的同时赋初值。
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};//结构体嵌套初始化

以上这几种初始化方法都是可行的，具体情况具体使用，都能够达到同样的效果

案例

struct Point
{
	int x;
	int y;
}p1 = {2,3};

struct score
{
	int n;
	char ch;
};

struct Stu
{
	char name[20];
	int age;
	struct score s;
};

int main()
{
	struct Point p2 = { 3,4 };
	struct Stu s1 = { "zhangsan", 20 , {100, 'q'}};
	printf("%s %d %d %c\n", s1.name, s1.age, s1.s.n, s1.s.ch);

	return 0;
}

---

5、结构体内存对齐（重点内容）

前言

我们首先来看两段代码对比一下：

#include<stdio.h>
struct p 
{
	char a;
	int b;
	char c;
};
int main()
{
	printf("%d\n", sizeof(struct p));
	return 0;
}

#include<stdio.h>
struct p 
{
	char q;
	char w;
	int e;
};
int main()
{
	printf("%d\n", sizeof(struct p));
	return 0;
}

大家认为这个结构体是多少个字节内存大小呢？
这里小编先公布答案：

1、

2、

大家可以看到这两个结构体大小怎么不一样呢？结构体内容一模一样，为什么一个是12字节，一个是8字节呢？

这就是我们今天要深入介绍的结构体的内存对齐：

A、规则

我们首先得掌握结构体规则：

这里用图的方式不好讲，光是图和文字大家也不太容易理解，我在b站找了比特教育的一位大佬的视频，相信小伙伴们看视频更加容易理解结构体内存对齐：

结构体内存对齐

大家看完上面链接的视频相信深有感悟，我再补充一些知识点就行：

B、知识点

a

这个对齐数只有再vs编译器里面才有，其他编译器比如说gcc等等编译器的对齐数就是变量本身，int就是4、char就是1，以此类推

b

我们怎么样来查看一个变量的偏移量呢？我们用一个offsetof宏就行，记住这是一个宏！！！

offsetof头文件是<stddef.h>

#include<stdio.h>
#include<stddef.h>
struct p 
{
	char a;
	int b;
	char c;
};
int main()
{
	printf("%d\n", offsetof(struct p, a));
	printf("%d\n", offsetof(struct p, b));
	printf("%d\n", offsetof(struct p, c));

	return 0;
}

struct p
{
	char q;
	char w;
	int e;
};
int main()
{
	printf("%d\n", offsetof(struct p, q));
	printf("%d\n", offsetof(struct p, w));
	printf("%d\n", offsetof(struct p, e));

	return 0;
}

大家如果看完链接视频会发现打印出来的偏移量是正确的，结构体变量的储存就是按照这样的方式来储存的

---

C、为什么会存在内存对齐呢？

有两个原因：

原因1

平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。

也就是说我们必须把一些数据对齐到我们可以取到这些数据的地方才能够使得数据被访问到并且被使用

原因2

性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
问。

案例

struct p
{
	char a;
	int b;
}:

所以说，通过内存对齐我们能够一次读取到变量b，这样大大提高了效率

那就有人要问了：为什么要浪费这么多空间用来就行内存对齐的？

因为提高了效率，这就是拿时间换空间的做法

小概括

总体来说：结构体内存对齐是拿空间换时间的做法

所以啊，我们以后在声明结构体变量的时候，既要节约空间，又要提高效率的做法是：

让占用空间小的成员尽量集中在一起，减少空间浪费

就像这样：

struct S2
{
 char c1;
 char c2;
 int i;
};

D、修改默认对齐数

既然对齐数是我们vs特有的，那么我们能不能就行对齐数修改呢？
答案是：肯定可以的！

这里就要用到我们的#pragma这个预处理指令

#pragma back( )-----这个括号里面放什么数据，那个数据就是我们更改得到的对齐数

注意

1、更改的对齐数不要使用负数，否则不仅会报错，答案也是错误的

2、更改的对齐数不要使用3或者5这些数字，因为有可能会浪费更多的空间，当然具体情况具体分析，大家要熟练使用

案例

1、

//#pragma pack()
struct p
{
	char a;
	double b;
};
//#pragma pack()
int main()
{
	printf("%zu\n", sizeof(struct p));
	return 0;
}

2、

#pragma pack(4)
struct p
{
	char a;
	double b;
};
#pragma pack()
int main()
{
	printf("%zu\n", sizeof(struct p));
	return 0;
}

小概括

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。

---

6、结构体传参

老规矩，上代码：

struct p
{
	int a[100];
	int b;
};
void print1(struct p s)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", s.a[i]);
	}
	printf("%d\n", s.b);
}
void print2(struct p* s)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", s->a[i]);
	}
	printf("%d\n", s->b);
}
int main()
{
	struct p s = { {10,20,30},100 };
	print1(s);//传值调用
	print2(&s);//传址调用
	return 0;
}

我们可以看到不管是传值调用还是传址调用都可以得到想要的答案，那么我们用哪一个更好呢？

答案是：传址调用！

为什么呢？

因为：

知识点

1、在函数调用的过程中，形参的实参的一份临时拷贝，然而传值调用的实参是一整个结构体，所以形参会在栈区创建一块空间来接收形参，这样栈空间就很大，时间和空间都有所下降。

2、而用传址调用就不会产生这种影响，因为传址传的是地址，一个地址在32位平台上占4个字节大小，64位平台上占8个字节大小，它所占用空间更小，效果自然而然就更好一些

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

那么就有人说：传值调用更安全啊，因为改变形参不会改变实参；而传址调用不安全，形参改变实参也改变了。

所以在传址调用基础上加上const修饰，这样不仅传参空间小、效率高，而且还安全

标准代码：

struct p
{
	int a[100];
	int b;
};
void print2(const struct p* s)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", s->a[i]);
	}
	printf("%d\n", s->b);
}
int main()
{
	struct p s = { {10,20,30},100 };
	print1(s);//传值调用
	print2(&s);//传址调用
	return 0;
}

小概括

结构体传参的时候，优先选择传结构体的地址。

---

二、位段

1、基本概念

1.位段的成员必须是char、 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

也就是说，位段成员必须是整型家族的成员；冒号后面的数字是比特位

样例

struct p
{
	int a : 2;
	int b : 5;
	int c : 10;
	int d : 20;
	int e : 30;
};

此时p就是一个位段类型，而仔细分析下来就是：

变量a需要2个比特位
变量b需要5个比特位
变量c需要10个比特位
变量d需要20个比特位
变量e需要30个比特位

为什么是这样的呢？

举个简单的例子：

如果有上面的变量a只需要表示真假，1表示真，0表示假，那么a只需要一个比特位就够了，因为a只表示0或者1

例子2

如果上面的变量b只要表示0到3，那么最大值3也就是二进制11只需要两个比特位就够了，所以说根本不需要用到一个整型的字节大小

小概括

位段是可以节省空间的

注意

冒号后面的值也就是给的比特位不能大于前面的类型最大值，不然就会报错

2、位段的内存分配

知识点

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

struct p
{
	int a : 2;
	int b : 5;
	int c : 10;
	int d : 20;
	int e : 30;
};
int main()
{
	printf("%d\n", sizeof(struct p));
	return 0;
}

那么上面位段代码要多少个字节呢？

为什么是这样的呢？
我来为大家分析分析：

位段是按照int或者char也就是4个字节或者1个字节来开辟空间的，因为上面代码的位段是int类型的所以说开辟4个字节

因为开辟4个字节空间放完c之后只剩下15个字节大小了，放不下d，那么再开辟一个4字节空间是必然的，但是d是接着c后面放还是直接在新开辟空间存放呢？这个我们是不知道的，C语言也没有明确规定，不过不管怎么样放，abcde全部储存都需要开辟12个字节，96个比特位；因为abcde比特位之和等于67，大于64也就是8个字节，所以开辟12个字节才放得下

注意

如果一个程序注重可移植性的话尽量少使用位段，因为位段是不跨平台的

案例

//一个例子
//一个例子
struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	//空间是如何开辟的？
}

我们来分析分析：

char类型的一次开辟一个字节：
先开辟一个字节，8个比特位存放a，还剩下5个比特位；

5个比特位存放b，还剩下一个比特位，这个时候再开辟一个字节空间是必须的，因为放不下c了，这个时候问题就来了：
开辟一个新字节c是接着b后面剩下的一个比特位存放呢？还是直接在新字节空间存放呢？

情况1：接着b后面剩下的一个比特位存放，那么就是第一个字节空间完了以后，c的第一个比特位被存放进去了，还剩下c的4个比特位和d的4个比特位，这个时候我们再开辟一个字节8个比特位就刚刚好存放完整个位段数据，一共是2个字节大小

情况2：如果c是直接存放在新的字节空间的，那么开辟第二个字节存放完c之后剩下3个比特位，存不下d，这个时候又要开辟一个字节来存放d，一共开辟了3个字节大小

那么到底是情况1还是情况2呢？
我们用sizeof查看一下：

看来啊，是我们的情况2啊！
弄清楚多少个字节了，接下来就该探讨这个位段类型是怎么存储的啦
一张图解决：

上面的a只有3个比特位的空间，但是将a赋值为10，10的二进制是1010，这有4个比特位，怎么办呢？

答案是只存放3个比特位，高地址处的1也就是最右边的数字1不要，直接把010存放到内存当中；

其他bcd也是同理：
如果二进制数据位数大于位段变量给定的比特位：存放的时候从低权值位开始存，给定多少个比特位就存多少个比特位的二进制数据，多余的二进制高权值位数据丢弃

如果二进制数据位数小于位段变量给定的比特位：将二进制数据存放完之后，缺少多少位数据就在前面补多少个0

注意

我们将赋值的数据转换成为二进制数据之后，不知道是从左向又还是从右向左存的，这里我们是猜测从右向左存的

说明我们刚刚的猜测是正确的，在vs2022的环境底下，数据是从右向左存放的

3、位段的跨平台问题

1. int 在位段里面被当成有符号数还是无符号数是不确定的。

2. 位段中最大位的数目不能确定。
（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。int在32位机器或者64位机器上占4个字节，但是在16位平台上占2个字节，如果我们这样写：int a:30；这个30在16位机器平台上面是错误的）

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
（刚刚我们猜测从右向左分配猜对了，也就是说vs2022环境下面位段中的成员在内存中是从右向左分配的）

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。

总结

跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

D、位段的应用(网络)

这里小编也是浅尝了解一下,等以后学到这方面知识点了在分享给大家!

三、枚举

1、概念

枚举顾名思义就是一一列举。
把可能的取值一一列举。

比如我们现实生活中： 一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举 这里就可以使用枚举了。

2、枚举类型的定义

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。

例如：

#include<stdio.h>
enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
int main()
{
	printf("%d\n", Mon);
	printf("%d\n", Tues);
	printf("%d\n", Wed);
	printf("%d\n", Thur);
	printf("%d\n", Fri);
	return 0;
}

当然在定义的时候也可以赋初值。

例如：

#include<stdio.h>
enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};
int main()
{
	printf("%d\n", RED);
	printf("%d\n", GREEN);
	printf("%d\n", BLUE);
	return 0;
}

3、枚举的优点

提问：

我们可以使用 #define 定义常量，为什么非要使用枚举？

优点1：

1.增加代码的可读性和可维护性

void menu()
{
	printf("*****************************\n");
	printf("****  1. add    2. sub  *****\n");
	printf("****  3. mul    4. div  *****\n");
	printf("****  0. exit          *****\n");
	printf("*****************************\n");
}
enum Option
{
	EXIT,//0
	ADD,//1
	SUB,//2
	MUL,//3
	DIV//4
};
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case ADD:
			break;
		case SUB:
			break;
		case MUL:
			break;
		case DIV:
			break;
		case EXIT:
			break;
		default:
			break;
		}
	} while (input);

	return 0;
}

我们可以根据枚举变量值的优点来改进代码，这样也就解释了为什么我们选1就是加，选2就是删，让代码的可读性与可维护性变的更高

---

优点2：

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
枚举是一个类型，而#define只是一个符号，枚举变量就相当于被封存起来了，具有某种类型了，更加严谨

优点3：

3. 防止了命名污染（封装）
我们就变量名放到enum里面类似于一种封装

优点4：

4. 便于调试
我们知道调试技巧是在程序运行完，出现.exe文件之后才能就行，然而#define会在程序编译之前的预处理阶段自动替换完，这就使得#define不能够进行调试

优点5：

5. 使用方便，一次可以定义多个常量
我们使用枚举类型可以直接在里面写入所有的变量名，而用#define就需要对每一个变量名进行从宏定义，代码太长了，过于复杂

4、枚举的使用

#include<stdio.h>
enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};
int main()
{
	enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
	clr = 5;
	printf("%d\n", GREEN);
	printf("%d\n", clr);
	return 0;
}

---

四、联合体（又称为共用体）

1、联合类型的定义

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

2、联合体的声明与定义

方法1：

//联合类型的声明
union Un
{
 char c;
 int i;
};
int main()
{
	union Un n;
	return 0;
}

union就是联合体关键字

方法2：

匿名联合体

union
{
 char c;
 int i;
}q;

2、联合体的特点

先来看一段代码：

#include<stdio.h>
union Un
{
	char c;
	int i;
};
int main()
{
	union Un un;
	//计算连个变量的大小
	printf("%d\n", sizeof(un));

	return 0;
}

或许有的人认为这里sizeof的答案是5，也许发生了联合体内存对齐是8？
其实都不是：

答案是4，只是为什么呢？这其实与联合体的特点相关：

特点1：

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小
(因为联合至少得有能力保存最大的那个成员）。

相信大家读完上面一段话都懂了，原来联合体内存至少是最大成员的大小，但这仅仅是至少，后面有其他情况。

关于上面一段代码就会有许多疑问：既然联合体大小是4，那么变量c和i是怎么样存放的呢？地址又分别是多少呢？
我们来探讨探讨：
首先是地址：

哎呀！ 我们发现这个联合体的地址与变量c，i的地址一模一样，那么根据这个地址信息我们可以画出c和i是怎么存储的：

也就是是i的地址与c的地址重合了。

特点2：

联合体内部的成员变量一次只能操作一个；当联合体内部成员变量大于2时，修改某一个成员变量会导致其他成员变量发生改变

案例：

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

}

我们发现在存放的时候c的地址修改掉了i的地址，这也正好对应了我们上面的特点2。

面试题

判断当前计算机的大小端存储

这道题我们以前做过，现在用联合体做一遍，看看两者的差异：

以前的版本：

#include<stdio.h>
int sait()
{
	int a = 1;
	return *(char*)&a;
}
int main()
{
	int ret = sait();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}

再来看看联合体版本：

#include<stdio.h>
int sait()
{
	union un
	{
		int a;
		char b;
	}u;
	u.a = 1;
	return u.b;
}
int main()
{
	int ret = sait();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}

可以看到答案是一样的

4、联合体计算的大小

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

是不是有小伙伴认为答案是5和7或者其他答案，其实不然
这两个printf的结果是：

这里其实和上面的结构体内存对齐一样，发生了联合体内存对齐，而且与上面结构体内存对齐规则一模一样，小伙伴们一定要注意再注意

总结

本篇文章我花了好几天才断断续续的写完，也许还是有许多知识点没有说清楚，大家如果有不懂的地方可以下了私聊小编，暑假两个月小编都在线，也希望本期内容对各位有所帮助。我们下期见！