结构体，联合体，枚举类型

WindFall1314

已于 2022-07-16 00:31:33 修改

阅读量632

点赞数 6

分类专栏： C刷题记录文章标签： c语言

于 2022-07-16 00:27:02 首次发布

本文链接：https://blog.csdn.net/qq_57238876/article/details/125814507

版权

C刷题记录专栏收录该内容

5 篇文章 0 订阅

订阅专栏

结构体，联合体，枚举类型

😘一.结构体

1.1🐣 结构的基础知识

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

1.2💕 结构的声明

struct tag
{
member-list;
}variable-list;

例如描述一个学生：

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

1.3 💖特殊的声明

结构体与联合体都存在匿名类型的，特点是随用随写，但是只能使用一次。

//匿名结构体类型
struct
{
    int a;
    char b;
    float c;
}x;
struct
{
    int a;
    char b;
    float c;
}a[20], *p;

表面看来，这两个类型相同，但是这两个结构体是匿名的，编译器会把他们当作不同的类型，如果写出p=&x的代码，就会报错，应为他们的类型的是不同的。

1.4 👍结构体的自引用

也许你听过指针的解引用操作，但是自引用又是什么了？简单的理解，就是结构体的成员中存在一个同结构体类型的指针，也就是这个指针管理的类型为该类结构体。

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

自引用的结构体的是没有匿名类型的，因为匿名的结构体只能使用一次，就会产生一个先有鸡还是先有蛋的说法，结合代码来看一下：

typedef struct
{
    int data;
    Node* next;
}Node;
//typedef是对存在的类型进行重命名，那么stuct后面的匿名结构体必须存在，他的存在意味着Node*这种类型也必须存在，而这种类型又是typedef重命名后产生的类型取地址产生的，聪明的你理解了吗？

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

变量的定义相信大家很熟悉，就是用类型去内存种开辟空间，结构体的申明已经了解到了，这时候我们就可以把它看作一种类型，到内存中去申请空间。

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};//结构体嵌套初始化

理解到他是一种类型，并能知道多个变量同时初始化需要用到花括号（”{}“）理解上面的代码就不难了。

1.6 🤡🤡🤡结构体内存对齐🤡🤡🤡（大小均指字节数）

我们已经掌握了结构体的基本使用了。现在我们深入讨论一个问题：计算结构体的大小。你可能会说，这还不简单，把每个成员变量的大小加起来不就好了吗，这是真的吗？且看我们一一道来。

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

这里会打印什么了？1+4+1=6？

这时候你可能开始怀疑编译器了，这是个什么”弱智“，别激动，想了解结构体在内存中是怎样分配的，我们必须知道结构体内存对齐的概念。

首先得掌握结构体的对齐规则：

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的值为8
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

结构上面的规则，我画了一个示意图：

其中的灰色表示开辟但未使用的空间！

你可能看懂了内存对齐的规则，但是会问，这是为什么了，看起来好像白白浪费空间！

下面我们来找找原因：

平台原因(移植原因)：

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

性能原因：

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

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

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

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

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

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

1.7 😒修改默认对齐数

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

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

当我们把默认对齐数设置为1的时候，结构体就是一个”假数组了“，相邻存放，但是元素类型不能保证相同了。

1.8 😍结构体传参

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

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

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

二.位段

2.1😂什么是位段

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

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

2.2🤣 位段的内存分配

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

//一个例子
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;
//空间是如何开辟的？

2.3 🤡位段的跨平台问题

int 位段被当成有符号数还是无符号数是不确定的。
位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
器会出问题。
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的。
总结：
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

三.枚举

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=2,
    BLUE=4
};

3.2 枚举的优点

很多同学对于枚举的作用不是很清楚，下面我们来详细说明一下枚举常量的优点吧！

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

这个是什么意思了，举个栗子吧，因为我们枚举常量是有取值的，有时候我们在使用switch语句的时候，case分支所代表的意义我们不能一眼的了解清楚，这个时候我们就可以利用枚举常量，做到见名知意。

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

枚举也是一种类型，但这种类型检查在c语言中体现的不是很明显，在c++中会很明显。

我们在c和c++的条件下去编译这样的代码：

enum Color//颜色
{
RED=1,
GREEN=2,
BLUE=4
};
int main(){
    enum color c=2;
}

c：没有任何的警告！！！

c++:我们能清晰的看见编译器会报出warning,"int"类型的值不能用于初始化"color"类型的实体

防止了命名污染（封装)
便于调试

这一点，我们可以好好说道说道。

首先我们得知道.c文件怎么变成exe文件的，经历了什么样的过程。

#define定义的标识符常量是在预处理阶段的时候就进行了代码替换，而我们调制的是exe文件，也就是说我们不能够对这种标识符常量进行跟踪观察，而枚举常量是可以的！

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

3.3 枚举的使用

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

四.联合（共用体）

4.1 联合类型的定义

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

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

4.2 联合的特点

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

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

这里取出成员i，c的地址，可以类比理解为取出数组和数组元素的地址，数组的地址是第一个字节的地址，而数组元素下标为0的位置当然也是第一个字节的位置！

解决第二个问题，我们得知道大小端字节序，大部分得机器是小端得存储方式，底位放在底地址（字节）出，所以在内存中得分布我们直接上图：

所以最终结果是：1122334455

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