您好，欢迎来到纷纭教育。
科技 教育 生活 旅游 时尚 美容 美食 健康 体育 游戏 汽车 家电
搜索
您的当前位置：首页C语言的自定义类型

C语言的自定义类型

来源：纷纭教育

结构体讲解

1、结构体的声明

结构体声明的写法

1、直接创建结构体

//学生
struct Stu {
	//学生的相关属性
	char name[20];//姓名
	int age;//年龄
	char number[10];//学号
};

2、创建结构体的同时创建结构体变量

//学生
struct Stu {
	//学生的相关属性
	char name[20];//姓名
	int age;//年龄
	char number[10];//学号
} s1,s2;

这里的s1 ， s2是结构体的变量
注意s1前面要加空格！
3、匿名结构体类型

//学生
struct{
	//学生的相关属性
	char name[20];//姓名
	int age;//年龄
	char number[10];//学号
}s1;

匿名结构体类型只能用一次，具体的用法是直接在后面加变量。

结构体的自引用

struct node {
	int data;
	struct node* next;//指向下一个结构体的位置
};

结构体的初始化

1、结构体定义的同时初始化

struct st {
	int x;
	int y;
} st1 = { 1,2 };

结构体声明后直接初始化。
st1前的是结构体类型，后面创建的st1才是真正有意义的，可以使用的。

2、创建后初始化

struct st {
	int x;
	int y;
} st1 = { 1,2 };

int main()
{
	struct st s2 = { 1,3 };
	return 0;
}

3、结构体嵌套的初始化

#include <stdio.h>
struct stu {
	int x;
	int y;
};
struct stu1 {
	char a[20];
	int b;
	struct stu s2;
};
int main()
{
	struct stu1 s1 = { "nb",6,{1,2} };
	printf("%s %d %d %d", s1.a, s1.b, s1.s2.x, s1.s2.y);
	return 0;
}

上面的st2结构体的第三个参数也是结构体，给st2初始化时也要同时给它的第三个参数初始化，初始化的时候要加 { } 这个符号。
打印结果：

2、结构体内存对齐

怎么去计算一个结构的大小呢？下面通过几个代码来看一看结构体中的成员给的内存空间是如何分配的。

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

我们都知道类型是有大小的，比如 int 型大小是4个字节，char 型大小是1个字节，那么上面代码的两个结构体的大小是多少呢？是6吗？
下面给出答案：

根据这个规则，我们来图解分析一下。

#include <stdio.h>
struct S3
{
	double d;
	char c;
	int i;
};

struct S4
{
	char c1;
	struct S3 s3;
	double d;
};

int main()
{
	printf("%d\n", sizeof(struct S4));
	return 0;
}

在这一种有内嵌结构体的情况，大小又该是多少呢？
给出答案：

宏查看偏移量

#include <stdio.h>
#include <stddef.h>
struct S3
{
	double d;
	char c;
	int i;
};
int main()
{
	printf("%d\n", offsetof(struct S3, d));
	printf("%d\n", offsetof(struct S3, c));
	printf("%d\n", offsetof(struct S3, i));
	return 0;
}

结果：

为什么存在内存对齐?

3、位段

下面我们来讲讲结构体来实现位段的能力。注意，位段是只有结构体才能实现

什么是位段

位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

比如：

struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};

这样的结构体就是一个位段类型。其中冒号后面的数字代表着给这个数字在内存中分配了多少个bite位的大小。那么位段A的大小是多少呢？
看类型是四个整型数据，那么大小是不是16个字节呢？
如果不是，根据上面给出的bite为的大小，共47位，那么48个bite的内存大小就足够放下这个结构体，所以猜测答案应该是6，那么到底是不是呢？

答案：

通过编译器的打印，我们可以看出这个结构体的大小是8个byte。那么为什么呢

位段的内存分配

1.位段的内存分配规则

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

struct S
{
char a:3;
char b:4;
char c:5;
char d:4;
};
struct S s = {0};
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;

下面以图解的方式来讲解下位段类型是如何分配内存的。



从上面的分析来看，我们的猜测是正确的。

位段的跨平台问题

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

2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。
总结： 跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

位段的应用

位段的应用主要是在网络上应用，试想一下网络好比高速公路，数据就是车辆，你数据越小，就说明车辆越小，高速公路就越顺畅，也就是网络越顺畅，不过位段应用时要注意跨平台问题。

4、枚举

枚举的概念

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

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

枚举类型的定义

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


假如我们不希望枚举常量是从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;
}



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


我们如果只是给第一个枚举常量赋值，后面都是递增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、和#define定义的标识符比较枚举有类型检查，更加严谨。 枚举是一个类型，而#define只是一个符号，枚举变量就相当于被封存起来了，具有某种类型了，更加严谨

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

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

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

枚举的使用

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

5、联合体（共用体）

联合体的定义

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

联合体的声明

第一种方法

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

union 就是联合体的关键字
第二种就是匿名联合体

union
{
 char c;
 int i;
}q;

联合体的内存分配

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

	return 0;
}

来猜测一下这里打印的是多少？是4？是8？
答案：

答案是4，那么为什么呢？我们来看下联合体的特点

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

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

	return 0;
}

特点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 = 0x10203040;
	un.c = 0x57;
	printf("%x\n", un.i);

}

联合体的内存大小问题

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

先来做做这里的题，想想答案应该是多少

联合体的内存分配是和结构体的内存对齐规则一样的，所以想要了解，可以翻看上面的结构体的内存分配。

用联合体判断大小端模式

大小端是指内存中数据的存储的方向问题，如图所示


那么我们可以写一个函数来判断编译器是采用小端模式还是大端模式

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


那么现在我们通过使用联合体来判断编译器是大端还是小端

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


可以看到答案是一样的，分析如下图所示

总结：个人博客写的并不是很好，其中有些知识点并不是写的很好，但也还是希望能给大家带来一些帮助，如果有问题可以私聊提出，评论也行，谢谢各位的支持

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

Copyright © 2019- fenyunshixun.cn 版权所有 湘ICP备2023022495号-9

违法及侵权请联系：TEL:199 18 7713 E-MAIL:2724546146@qq.com

本站由北京市万商天勤律师事务所王兴未律师提供法律服务