【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环境下没有默认对齐数，没有默认对齐数时，对齐数就是成员自身大小。
• 当成员全部放进去后，结构体的总大小必须是所有成员的对齐数中最大对齐数的整数倍。如果不够，则浪费空间对齐。
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

思维图解：

 那到底真的是这样吗，我们可以通过代码来进行验证：

• 调试看地址法

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

• 宏 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进行保护。

---

感谢大家能够看完这篇博客，创作时长，小伙伴们觉得我的博客对你有帮助，不妨留下你的点赞的收藏，关注我，带你了解不一样的C语言。