C语言:自定义类型

想学好C++的oMen

已于 2023-07-19 02:20:01 修改

阅读量174

点赞数 13

分类专栏： C语言学习文章标签： c语言开发语言

于 2023-07-18 21:17:24 首次发布

本文链接：https://blog.csdn.net/Kuzuba/article/details/131796595

版权

C语言学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

自定义类型:结构体,枚举,联合

1. 结构体

1.1 结构的基本知识

结构是一个或多个变量的集合,这些变量可能为不同的类型,为了处理的方便而将这些变量组织在一个名字之下.

由于结构将一组相关的变量看作一个单元而不是各自独立的实体,因此结构有助于组织复杂的数据,特别是在大型的程序中.

例如描述一个坐标(x,y),可以采用结构来存放这两个坐标:

struct point
{
    int x;  //横坐标
    int y;  //纵坐标
};//分号不能丢

关键字struct引入结构声明.结构声明由包含在花括号内的一系列声明组成.

struct后面的名字是可选的,称为结构标记(例如point).

结构标记用于为结构命名,再定义之后,结构标记就代表花括号内的声明,可以用它作为该声明的简写形式.

struct声明定义了一种数据类型.在标志结构成员表结束的右花括号之后可以跟变量名,这与其他基本类型的变量声明是相同的,例如:

struct {...}x,y,z;

从语法角度来说,这种方式的声明与声明

int x, y, z;

是具有类似的意义的.都是将x,y,z声明为指定类型的变量,同时为变量分配与类型相匹配的内存空间.

如果结构声明的后边不带变量,则不需要为它分配存储空间,它仅仅描述了一个结构的模板和轮廓.(相当于建筑的模型图).

如果结构声明有结构标记,那么在以后定义结构体变量的时候可以省略内部声明,例如:

struct point pt;

直接定义了一个结构体变量pt.结构的初始化使用{}进行赋值,例如

struct point maxpt = {320, 200};

可以在创建变量的时候直接使用初值表进行初始化,也可以直接在结构声明的时候进行创建变量初始化

struct point
{
    int x;
    int y;
}a = {100, 100};

若没有结构标记,即为匿名结构体类型,例如:

struct
{
	int a;
	char b;
	float c;
}x;

struct
{
	int a;
	char b;
	float c;
}a[20], *p;

上述两个结构体声明省略了结构标记,虽然上述两个结构体声明内容是一样的,但是编译器会把上面的两个声明当作两个完全不同的结构体类型.
若令p = &a,这条表达式是非法的!

1.2 自引用结构

结构的自引用是指在结构定义中包含对自身类型的引用.这种自引用可以通过在结构中使用指针来实现.具体而言,可以在结构定义中声明一个指向相同结构类型的指针成员.

正确的自引用方式:

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

这种对节点的递归的声明方式看上去好像是不确定的,但它的确是正确的.一个包含自身实例的结构是非法的,但是下列声明是合法的:

struct Node* next;

它将next声明为一个指向Node的指针,而不是指向Node实例本身.

注意: 若使用类型定义typedef,来重命名自引用结构,只能这样:

//方法一
typedef struct Node
{
    int data;   //数据域
    struct Node* next;  //指针域
}* linklist;

//方法二
struct Node
{
    int data;   //数据域
    struct Node* next;  //指针域
};

typedef struct Node* linklist;

严禁在声明内部使用还未重命名完全的类型.

同时,偶尔也会有互相引用的情况,例如:

struct t
{
    ...
    struct s* p;
};

struct s
{
    ...
    struct t* q;
};

1.3 结构体内存对齐

许多计算机系统对基本数据类型的合法地址做出了一些限制,要求某种类型对象的地址必须是某个值K(通常是2,4,8)的倍数.这种对齐限制简化了形成处理器和内存系统之间接口的硬件设计.

例如,假设一个处理器总是从内存中取 8 个字节,则地址必须为 8 的倍数.如果我们能保证将所有的 double 类型数据地地址对齐成 8 的倍数,那么就可以用一个内存操作来读或者写值了.否则,我们可能需要执行两次内存访问,因为对象可能备份放到两个 8 字节内存块中.

结构体成员的偏移量是相对于结构体起始位置的偏移量(字节为单位),在C语言中,可以利用宏offsetof求出偏移量.通过偏移量,我们可以直观感受到内存对齐.

宏offsetof(type, member): <stddef.h>

参数:
- type:结构体类型
- member:结构体成员
返回值:
- 返回成员相当于结构体类型起始位置的偏移量,类型为size_t
使用实例:

#include <stdio.h>
#include <stddef.h>

struct s1
{
    char a;
    int b;
    char c;
};

int main(void)
{
    printf("%d\n", sizeof(struct s1));
    printf("%d\n", offsetof(struct s1, a));
    printf("%d\n", offsetof(struct s1, b));
    printf("%d\n", offsetof(struct s1, c));
    return 0;
}

程序运行结果如下:

通过上述程序,可以明确的感受到内存对齐.虽然结构体成员a是char类型的,正常应该只占1个字节,但是因为内存对齐,b确存放在了偏移量为4的位置上,浪费了3字节空间.
在这里插入图片描述

1.3.1 内存对齐规则

第一个成员在与结构体变量的偏移量为 0 的地址处.
其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处.
对齐数 = 编译器默认的一个对齐数与该成员大小中的较小值
VS中默认对齐数为 8
Linux中没有默认对齐数,对齐数就是成员自身的大小

结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍.
如果嵌套了结构体的情况,嵌套的结构体也是一个成员变量,一样按照上述规则.嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍.

1.3.2 题目练习

练习1

struct s1
{
    char c1;
    int i;
    char c2;
};
printf("%d\n", sizeof(struct s1));

在这里插入图片描述

结果应为: 12
在这里插入图片描述

练习2

struct s2
{
    char c1;
    char c2;
    int i;
};
printf("%d\n", sizeof(struct s2));

在这里插入图片描述

结果应为: 8

练习3

struct s3
{
    double d;
    char c;
    int i;
};
printf("%d\n", sizeof(struct s3));

在这里插入图片描述

结果应为: 16
在这里插入图片描述

练习4

struct s4
{
    char c1;
    struct s3 s;
    double d;
};
printf("%d\n", sizeof(struct s4));

在这里插入图片描述

结果应为: 32
在这里插入图片描述

1.3.2 内存对齐原因

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

总体来说:

结构体的内存对齐就是拿空间换取时间的做法.

那么设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到:

让占用空间小的成员尽量集中在一起

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

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

struct s1和struct s2虽然成员一摸一样,但是s2所占空间为8个字节,而s1所占字节为12个字节.

1.3.4 修改默认对齐数

可以使用#pragma预处理指令,来修改默认对齐数
在觉得默认对齐数不合适的时候,可以自己更改默认对齐数.

#include <stdio.h>
#pragma pack(8) //设置默认对齐数为8
struct s1
{
	char c1;
	int i;
	char c2;
};
#pragma pack() //取消设置的默认对齐数,还原为默认

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

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

运行结果为: 在这里插入图片描述

2. 位段

在存储空间很宝贵的情况下,有可能需要将多个对象保存在一个机器字中.

C语言提供了直接定义和访问一个字中的位字段的能力.

2.1 什么是位段

位字段(bit-field),或简称字段,是"字"中相邻位的集合.

位段的声明和结构是类似的,有两个不同:

位段的成员必须是int, unsigned int, signed int
位段的成员名后面有一个冒号和一个数字

例如:

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

A就是一个位段类型,那么A的大小又是多少呢?

printf("%d\n", sizeof(struct A));

得到结果为: 在这里插入图片描述

一个int类型一共有32位,能存放_a,_b,_c一共17位空间,但是剩下的15位却不能存放30位的_d.所以总共需要两个int类型大小的空间,才能存放这个结构体.也就是结果的8个字节.

2.2 位段的内存分配

位段的成员可以是int,unsigned int,signed int,char类型
位段的空间实际上是按照4个字节(int)或者1个字节(char)来开辟的
位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段.(原因是c语言对位段的规定太过宽泛).

若想知道,位段的元素究竟是从低地址开始存?如果剩余的二进制位不够存储,是直接在新的空间开始存储,还是先填满剩余空间,再继续存储?

则需要进行具体调试分析,有如下代码:

#include <stdio.h>

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};

int main(void)
{
	struct S s = { 0, };
	s.a = 10;
	s.a = 12;
	s.c = 3;
	s.d = 4;
}

得到结果是: 在这里插入图片描述

通过调试得出以下结果:
在这里插入图片描述

在VS2022环境下,先存放到高地址位置,若不够,则直接开辟新的空间.

2.3 位段的跨平台问题

int位段被当成有符号数还是无符号数是不确定的
位段中的最大数目不能确定.(16位机器最大16,32位机器最大32,写成27,在16位机器会出问题)
位段中的成员从左向右分配,还是从右向左分配标准尚未定义.
当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,是不确定的.

总结:

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

2.4 位段的应用

例如网络底层,网络IP数据包格式:
在这里插入图片描述

3. 枚举

枚举是一个常量整型值的列表,把可能的值一一列举

例如:

一周的周一到周日是有限的7天
性别有男,女和保密
月份有12个月

3.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 = 3,
    BLUE = 5
};

3.2 枚举的优点

我们可以用宏定义#define,常变量const来定义常量,为什么要用枚举呢?

枚举的优点:

增加代码的可读性和可维护性
和#define相比枚举类型有类型检查,更加严谨
便于调试
使用方便,一次可以定义多个常量

3.3 枚举的使用

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

enum Color clr = GREEN; //只能拿枚举常量赋值给枚举类型的变量,这样才不会出现问题
clr = 5;                //这样写是错误的,在类型检查相对严谨的c++中,会直接报错

4. 联合(共同体)

4.1 联合类型的定义

联合也是一种特殊的自定义类型

这种类型定义的变量也包含一系列的成员,特征是这些成员公用同一块空间

比如:

#include <stdio.h>
//联合类型的声明
union Un
{
	char c;
	int i;
};

int main(void)
{
	//联合变量的定义
	union Un un;

	//计算整个联合变量的大小
	printf("%d\n", sizeof(un));

	//return 0;
}

程序运行结果如下: 在这里插入图片描述

一个联合类型要在(不同时刻)保存所有类型的成员变量,所有成员变量公用一块空间,这就需要联合类型变量的大小要和其成员变量中占据的最大内存大小一样.

上述代码,char类型占据1字节空间;int类型占据4字节空间;所以最终整个联合类型变量的大小是4.

4.2 联合的特点

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

#include <stdio.h>

union Un
{
	int i;
	char c;
};

int main(void)
{
	union Un un;

	//下面输出的结果是一样的吗?
	printf("%p\n", &(un.i));
	printf("%p\n", &(un.c));

	//下面输出的结果是什么?
	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.i);

	return 0;
}

联合所有的成员变量共用一块空间,则它们的地址是一样的.
最后应该打印11223355
程序运行结果如下:

用联合判断计算机的大小端存储

下面还有一道面试题:

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

之前已经直接用取低地址一字节数据的方式来判断,具体详见深度剖析数据在内存中的存储

这里用刚学的联合类型知识来解决:

#include <stdio.h>

union Un
{
	int i;
	char c;
};

int check_sys()
{
	union Un un;
	un.i = 0x00000001;
    //低地址 --> 高地址
    //小端: 01 00 00 00
    //大端: 00 00 00 01
    
    //变量都是从低地址开始取的
	return un.c;
}

int main(void)
{
	int ret = check_sys();

	if (ret)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}

	return 0;
}

程序运行结果如下: 在这里插入图片描述

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

Un1: char c[5]中的大小为 5 ,对齐数为 1 ;int i中的大小为 4, 对齐数为 4; 5 不是 4 的倍数,所以应该为 8.
Un2: short c[7]中的大小为 14, 对齐数为2; int i中的大小为 4,
对齐数为 4; 14 不是 4 的倍数, 所以应该为 16.
程序运行结果为: