【C语言】自定义类型：结构体，枚举，联合

C语言有内置类型 char，short，int，long，float ，double，这些类型是我们直接就能够用的。除了这些类型，C语言还允许我们自己创造一些类型，这些类型我们称为自定义类型，其包括结构体，联合体，枚举类型等等。接下来我将详细介绍这些自定义类型。

结构体

结构的基础知识

结构体是一些值的集合，这些值称为成员变量。结构体的每个成员可以是不同类型的变量。讲到集合，就不得不提到数组，但与结构体不同的是，数组是一组相同类型元素的集合。

结构的声明

//结构体声明的基本方式
struct tag
{
    member-list; //成员列表
}variable-list; //变量列表

举个例子，描述一个学生，代码示例如下：

//定义学生类型
struct Stu
{
char name[20];    //名字
int age;          //年龄
float weight;     //体重
}s4,s5,s6;    //全局变量
 
int main()
{
    //利用定义的学生类型来创建变量
    struct Stu s1;   //局部变量
    struct Stu s2;
    struct Stu s3;
    return 0;
}

在该代码中，我们既可以在定义完结构体类型后直接创建变量（也就是结构体声明的基本方式中的变量列表一栏），也可以在main函数内部来创建变量，但二者也有差异：在定义完结构体后直接创建出来的变量为全局变量（可以没有，也可以有多个），而在main函数中创建的变量为局部变量。

特殊的声明

特殊声明指在声明结构体的时候，可以不完全的声明，即可省略结构体的名字。我们将这样的结构体类型称为匿名结构体类型。

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

对于匿名结构体类型而言，是可用的，但是必须在定义完匿名结构体类型后直接创建所需的变量。但这也使得创建的匿名结构体类型的变量在整个工程中只能被使用一次，因为在第二次使用时没有结构体类型的名字，因此不能成功的创建该变量。

匿名结构体类型的易错点：

struct 
{
    char c;
    int a;
    double d;
}s1;
 
struct 
{
    char c;
    int a;
    double d;
}*ps;
 
int main()
{
    ps = &s1;  //err
    return 0;
}

报错列表：

那么出现这种错误的原因是什么呢？原来在编译器看来，虽然 s1 和 *ps 的结构体类型成员是一模一样的，但是编译器会把上面的两个声明当成完全不同的两个类型。因此不要这样去使用匿名结构体类型。

结构的自引用

在理解结构的自引用时，在这里引出数据结构，数据结构本质上描述的是数据在内存中的数据结构。在数据结构中存储一组在内存中散乱排布的数据（1，2，3，4，5），需要用到链表:

为了能够通过该结点找到下一个结点，因此我们声明的结构体类型应该既包含自己的数据，又包含下一个结点的信息，所以应该这样声明结构体类型：

struct Node
{
    int data;
    struct Node next;
}; //err sizeof(struct Node)是多大呢？要开辟的内存又不可知，因此此写法错误
 
//正确的自引用方式：
struct Node
{
    int data;
    struct Node* next;
};

typedef struct
{
    int data;
    Node* next;
}Node; //err
 
//正确的自引用方式:
typedef struct Node
{
    int data;
    struct Node* next;
}Node;

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

有了结构体类型，那如何定义变量和初始化变量就很简单了：

//结构体变量的定义
 
struct S
{
    int x;
    int y;
}s1; //声明类型的同时定义变量s1  ……  1
 
struct S s2;   //  ……  2
 
int main()
{
    struct S s3;    // ……  3
    return 0;
}

//结构体变量的初始化
 
struct S
{
    int a;
    char c;
};
 
struct B
{
    float f;
    struct S s;
};
 
int main()
{
    struct S s2 = {100,'q'};
    struct B sb = {3.14f,{200,'w'}};
    return 0;
}

监视器内容：

也可以用一种有逼格的初始化方式–不按照顺序进行指定初始化：

struct S
{
    int a;
    char c;
};
 
struct B
{
    float f;
    struct S s;
};
 
int main()
{
    struct S s2 = {100,'q'};
    struct S s3 = { .c = 'r', .a = 2000};
    struct B sb = {3.14f,{200,'w'}};
    return 0;
}

监视器内容：

结构体内存对齐

我们可以深入讨论一个问题：计算结构体的大小。这也是一个特别热门的考点： 结构体内存对齐

struct S1
{
    int a;
    char c;
};
 
struct S2
{
    char c1;
    int i;
    char c2;
};
 
struct S3
{
   char c1;
   int a;
   char c2;
   char c3;
};
 
int main()
{
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
    printf("%d\n", sizeof(struct S3));
    return 0;
}

代码运行结果如下：

结构体的对齐规则：

• 结构体的第一个成员永远放在0偏移处。 从第二个成员开始，其他成员变量都要对齐到某个数字（对齐数）的整数倍处。
• 这个对齐数是：成员自身大小和默认对齐数的较小值。
• VS默认对齐数为8；gcc环境下没有默认对齐数，没有默认对齐数时，对齐数就是成员自身大小。
• 当成员全部放进去后，结构体的总大小必须是所有成员的对齐数中最大对齐数的整数倍。如果不够，则浪费空间对齐。
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

思维图解：

我们可以通过代码来进行验证：

1. 调试看地址法
   

我们可以发现结构体s的成员c的地址和成员a的地址差了4，确确实实验证了这里出现了空间浪费，地址偏移。

2. 宏 offsetof 计算偏移量
   

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

结构体嵌套问题:

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

思维图解：

为什么存在内存对齐?

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

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

总而言之，结构体的内存对齐是拿空间来换取时间的做法。

虽然内存对齐可以通过牺牲空间使性能大幅提高，但也不能无脑浪费，有一些空间我们还是可以通过一些手段来节省下来，那在设计结构体的时候，我们既要满足对齐，又要节省空间，就应该做到：让占用空间小的成员尽量集中在一起。

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

修改默认对齐数

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。#pragma 这个预处理指令，这里我们再次使用 #pragma pack()，可以改变我们的默认对齐数。

#pragma pack() 的基本使用：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
#pragma pack(1)  //设置默认对齐数为1
struct S1
{
    char a;
    int b;
    char c;
};
#pragma pack()  //取消设置的默认对齐数，还原为默认
 
struct S2
{
    char a;
    int b;
    char c;
};
 
int main()
{
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
    return 0;
}

结构体传参

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(const struct S* ps)
{
    printf("%d\n", ps->num);
}
int main()
{
    print1(s); //传结构体
    print2(&s); //传地址
    return 0;
}

在学习函数一节中我们提到，函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
同样的如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

当然无论是传值还是传址，都各有利弊，比如：传值的好处是由于形参是实参的一份临时拷贝，因此实参在一定程度上被保护了起来；传址若是不想被修改，可以在函数参数上加上const进行保护。

位段

什么是位段

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

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

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

上图代码 A就是一个位段类型。那我们继续来测试一下位段A的大小：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
struct A
{
    int _a : 2;
    int _b : 5;
    int _c : 10;
    int _d : 30;
};
 
int main()
{
    printf("%d\n", sizeof(struct A));
    return 0;
}

这可能与大家预期的16有一些差距，那么想要真正理解位段，我们就必须来学习一下位段在内存中的分配规律。

位段的内存分配

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

举个例子：
 
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
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;
    return 0;
}

在VS环境下s的位段在内存中的分配情况通过调试可得：

思维图解：

位段的跨平台问题

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

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

位段的应用

数据传输的格式封装：

要是将数据包的每个部分都用int，甚至是char都造成了非常大的空间浪费。因此这里我们可以通过位段来节省空间，让每个部分都占据尽可能小的空间，从而使整个数据包的大小变小。

将网络想象成一个数据的高速公路，如果数据都较大，即便是一个较小的数据包再快，它也无法越过比它大的在它前的数据包，只能按照顺序一个一个进行传输。如果能够使得数据包能够尽可能地缩小，那么整个网络上单位时间内传输的数据就会更多，速度也会相应的加快，变小意味着变快。

枚举

枚举类型的定义

枚举：将可能的取值一一列举。比如：一周的天数、性别、一年的月份等等可以使用枚举来将其可能出现情况列举出来。

枚举类型的基本使用：

enum Sex//性别
{
    //枚举的可能取值，默认是从0开始，递增1
    //列举出来的情况本质上是数字
    //
    MALE,
    FEMALE,
    SECRET
};
 
int main()
{ 
    printf("%d\n", MALE);
    printf("%d\n", FEMALE);
    printf("%d\n", SECRET);
    return 0;
}

当然，我们也可以将这些枚举常量在定义时附上初始值，操作如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
enum Sex//性别
{
    //枚举的可能取值，默认是从0开始，递增1
    //列举出来的情况本质上是数字
    //枚举常量
    MALE = 5,
    FEMALE,
    SECRET
};
 
int main()
{ 
    printf("%d\n", MALE);
    printf("%d\n", FEMALE);
    printf("%d\n", SECRET);
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
enum Sex//性别
{
    //枚举的可能取值，默认是从0开始，递增1
    //列举出来的情况本质上是数字
    //枚举常量
    MALE,
    FEMALE = 5,
    SECRET
};
 
int main()
{ 
    printf("%d\n", MALE);
    printf("%d\n", FEMALE);
    printf("%d\n", SECRET);
    return 0;
}

枚举的优点

枚举的优点：

• 增加代码的可读性和可维护性。比如：写小游戏的菜单
• 和#define定义的标识符比较枚举有类型检查，更加严谨。比如：#define定义的标识符常量是没有类型的。而使用枚举定义，其定义的常量是枚举类型，也是一种类型。
• 防止了命名污染（封装）。
• 便于调试。比如：创建枚举变量后调试可以在监视窗口看到枚举常量的值。
• 使用方便，一次可以定义多个常量。

枚举的使用

只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
enum Sex//性别
{
    //枚举的可能取值，默认是从0开始，递增1
    //列举出来的情况本质上是数字
    //
    MALE,
    FEMALE,
    SECRET
};
 
int main()
{ 
    enum Sex s = MALE;
    return 0;
}

联合（共用体）

联合类型的定义

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

为了方便大家理解举个例子：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
union Un
{
    char i;
    int a;
};
 
int main()
{ 
    union Un u;
    printf("%d\n", sizeof(u));
    printf("%p\n", &u);
    printf("%p\n", &(u.i));
    printf("%p\n", &(u.a));
    return 0;
}

图画理解：

当成员变量 i 占一个字节，成员变量 a 占四个字节，而整个联合体也占四个字节，我们发现成员变量 i 和成员变量 a 在共同使用空间。因此 i 变，a 也跟着变，a 变，i 也跟着变。我们在使用联合体时，在同一时间点只能用一个成员。

联合的优点

利用联合体成员共用同一块内存的特点，我们可以得出一种判断当前计算机的大小端存储的方法：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
union Un
{
    char c;
    int i;
};
 
int main()
{ 
    union Un u = { 0 };
    u.c = 1;
    if (u.i == 1)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}

联合大小的计算

联合体也是存在对齐规则的。

• 联合的大小至少是最大成员的大小。
• 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
union Un
{
    char arr[5];  //5    最大成员大小为5字节
    int i;  //4   最大对齐数为4字节
};
 
int main()
{ 
    printf("%d\n", sizeof(union Un));
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
union Un
{
    short s[7];  //14   最大成员大小为14字节
    int n;   //4   最大对齐数为4字节
};
 
int main()
{ 
    printf("%d\n", sizeof(union Un));
    return 0;
}

实现一个静态通讯录