C的追忆（4）——自定义类型

迷失之语

已于 2023-10-26 08:24:51 修改

阅读量89

点赞数 6

分类专栏： C的追忆 c语言文章标签： c语言开发语言

于 2023-10-12 04:59:20 首次发布

本文链接：https://blog.csdn.net/2301_77272486/article/details/133759537

版权

c语言同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

C的追忆

8 篇文章 0 订阅

订阅专栏

什么是C语言的自定义类型，我们肯定能第一时间想到结构体，但事实上C语言的自定义类型远不止结构体这一个，接下来就让我们来深入探讨一下C语言的自定义类型吧！

一.结构体

1. 结构体基本使用回顾

1.1 结构体定义：

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

1.2 结构体声明：

(1) 显式声明

如下是建立一个结构体描述一个学生：

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

(2) 隐式声明

即在声明结构体时不声明结构体名

//匿名结构体类型
struct
{
    int a;
    char b;
    float c;
}x;

注意：隐式声明的结构体是一次性的，只能在定义时使用一次，之后即使重复一遍声明，编译器仍旧会把两个结构体当成完全不同的两个类型。

例如一下两段代码：

//匿名结构体类型
struct
{
    int a;
    char b;
    float c;
}x;

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

即使是进行如下操作时：

p = &x;

编译器也会报出两结构体是不同类型的错误警告。

1.3 结构体自引用

(1) 什么是结构体自引用？

结构体自引用是指在结构体内部，包含指向自身类型结构体的指针。例如，一个学生结构体中包含一个指向自己的指针，可以用来表示学生的成绩。

如果多个结构体之间存在相互引用，即在多个结构体中，都包含指向其他结构体的指针，这种情况称为结构体的相互引用。

(2) 自引用操作

具体操作可参考如下代码：

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

注意：自引用绝对不能直接用结构体本身代替结构体指针，否则会陷入一种类似于死递归的恶劣错误中，当然一次性的隐式声明也不可取。

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

(1) 变量定义

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

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

(2) 初始化

struct Stu        //类型声明
{
    char name[15];//名字
    int age;      //年龄
};

struct Stu s = {"zhangsan", 20};//初始化，定义变量的同时赋初值。

(3) 结构体嵌套初始化

struct Node
{
    int data;
    struct Point p;
    struct Node* next;
}n1 = {10, {4,5}, NULL};	


//结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

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

上面的 print1 和 print2 函数哪个好些？

答案是：首选print2函数。

原因：

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

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

结论：

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

2. 结构体内存对齐（大小计算）

有人肯定会说会用就行，为什么我们要了解这个呢？

这里小编解释一下，第一是为了让我们能够清楚计算出结构体大小，第二是为了了解结构体如何储存，以便于更灵活的调整含结构体代码的空间复杂度（也就是占内存空间大小）。

下面我们先了解一下什么是内存对齐。

2.1 内存对齐的定义

内存对齐是指将数据存储在内存中的某个位置，这个位置必须是数据类型大小的整数倍。例如，对于一个int类型的变量，它的大小为4个字节，因此它必须存储在内存中地址是4的整数倍的位置上。

内存对齐可以提高CPU访问内存的效率和准确性。在某些条件下，如果没有对齐会导致数据不同步现象。

2.2 为什么要存在内存对齐？

1. 平台原因(移植原因)：

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

2. 性能原因：

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

2.3 结构体内存对齐规则

1. 第一个成员在与结构体变量偏移量为0的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。

3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

2.4 修改默认对齐数

上面对齐规则中提到了一个很重要的概念：编译器默认的对齐数 ,这是一个可修改的值，之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

使用示范如下：

#pragma pack(8)//设置默认对齐数为8


#pragma pack()//取消设置的默认对齐数，还原为默认



#pragma pack(1)//设置默认对齐数为1


#pragma pack()//取消设置的默认对齐数，还原为默认

结论：

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

2.5 结构体大小计算

第一个成员在与结构体变量偏移量（即距离结构体地址的字节数）为0的地址处，接着将第二个成员放在第二个成员的对齐数的整数倍地址偏移处（偏移量按照从0处开始算），要确保该存放地址上没有存放成员，正常为1倍，以此类推，最后算出当结构体所占内存不为成员最大对齐数整数倍时，要浪费字节数对齐进行补齐。

可参考下图：

2.6 如何设计结构体

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

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

示范如下：

//例如：

struct S1
{
    char c1;
    int i;
    char c2;
};//大小为12


struct S2
{
    char c1;
    char c2;
    int i;
};//大小为8

S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

总体来说：

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

3. 位段

3.1 什么是位段

这是一个基于结构体的基础上才能进行实现的类型，与结构体相似，主体差异体现在内存上。

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

1.位段的成员必须是 int、unsigned int 或signed int 。

2.位段的成员名后边有一个冒号和一个数字。

示范如下：

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

A就是一个位段类型。

3.2 位段的内存分配

上面我们说位段与结构体主要的不同在内存分配上，那么它是如何进行分配的呢？

大家肯定已经注意到成员后面冒号和数字了，相信大家猜到了，没错，这就是关键，数字代表的是以bit为单位的内存分配，数字为几，就分配几个bit位，一个字节8个bit位，一个bit位等于一个二进制位。

分配规则如下：

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型。

2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

请看下图示例：

注意：在vs环境下如果一个字节内部分配不够时，会直接开辟一个新字节，在新字节空间内分配，旧的空余直接不要了，不同环境可能有些不同。

3.3 位段的跨平台问题

一个有趣的问题，为什么位段听起来这么好，我们为什么不常见呢？

这是因为不合理的使用位段会出现很多问题。

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

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

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

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

总结：

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

3.4 位段的应用

那么位段常常在什么条件下使用呢？

最常见的就是网络底层数据的传输，位段可以有效提高数据传输效率，这里就不在深入了。

二. 枚举

4.枚举类型的定义

枚举顾名思义就是一一列举。

把可能的取值一一列举。

比如我们现实生活中：

性别有：男、女、保密，也可以一一列举。

月份有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，当然在定义的时候也可以赋初值。

例如：

enumColor//颜色
{

    RED=1,
    GREEN=2,
    BLUE=4
};

5.枚举的优点

为什么使用枚举？

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

枚举的优点：

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

        2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

        3. 防止了命名污染（封装）

        4. 便于调试

        5. 使用方便，一次可以定义多个常量

6.枚举的使用

直接见代码：

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

enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。

clr = 5;               //ok??

三.联合（共用体）

7. 联合类型的定义

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

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

定义示例代码：

//联合类型的声明
union Un
{
     char c;
     int i;
};

//联合变量的定义
union Un un;

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

8.联合的特点

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

示例如下：

9. 联合大小的计算

注意：

1.联合的大小至少是最大成员的大小。

2.当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

大家可以自行试试以下代码：

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