本文主要介绍了C语言入门到精通--【C语言进阶】自定义类型-结构体，通过具体的内容向大家展现，希望对大家C语言开发的学习有所帮助。

一、结构体类型的声明

首先我们来了解一下结构的基础知识：

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

如数组是一组相同类型的元素的集合，而结构体也是一些值的集合，结构体的每个成员可以是不同类型的。

结构的声明

struct tag

{

    member-list;

}variable-list;

//结构体关键字：struct

//结构体的标签：tag

//结构体的类型：struct tag

//结构的成员列表：member_list

//结构体变量列表：variable_list

例：

#include

//声明一个结构体类型

//声明一个学生类型，是想通过学生类型来创建学生变量(对象)

//描述学生：属性 - 名字+性别+年龄+电话号码

struct Stu

{

    char name[20]; //名字

    char sex[10];  //性别

    int age;       //年龄

    char phone[12];//电话

}; //记住这里要加分号

struct Stu s3;//全局变量

int main()

{

    //创建的结构体变量

    struct Stu s1;

    struct Stu s2;

    return 0;

}

特殊的声明

在声明结构的时候，可以不完全的声明。

例：

//匿名结构体类型

struct

{

    int a;

    char c;

}sa;

struct

{

    int a;

    char c;

}* psa;//匿名结构体指针类型

 思考：在上面代码的基础上，下面的代码合法吗？

int main()

{

    psa = &sa;

    return 0;

}

执行结果：

 警告：编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。

结论：当两个匿名结构体类型内部的内容一样时，仍然是两个不同结构体类型 

二、结构的自引用

思考1：在结构中包含一个类型为该结构本身的成员是否可以呢？

//代码1

struct Node

{

    int data;

    struct Node next;

};

思考2：可行吗？如果可以，那sizeof(struct Node)是多少？

解答：不行。

假设代码1中的方式可以执行，那么在创建结构体的过程中，struct Node next由于结构体struct Node类型还没创建完成，所以其类型的大小是未知的，而struct Node类型的是否能成功创建又依赖于struct Node next类型大小的确定性。

所以这两者自相矛盾。因此上述方法不行！

结构体正确的自引用方式

//代码2

struct Node

{

    int data;//4 数据域

    struct Node* next;//4/8 指针域

};

思考3：这串代码为什么可以成功呢？

解答：首先此处结构体自应用方式并不是直接利用结构体来创建变量，而是创建指向该结构体类型的指针。

我们知道，指针的大小跟其所指向的类型无关，仅跟平台环境有关，32位平台指针大小为4个字节，64位平台，指针大小为8个字节。

正因为指针大小的确定性，所以再自引用的时候结构体类型的整体大小也是可以确定的。

思考4：这样写代码可行吗？

//代码3

typedef struct

{

    int data;

    Node *next;

}Node;

解答：不行

由于此时struct后面省略掉了Node，所以匿名重新命名结构体为Node，那么此时编译器就会不认识Node。（就好比先有鸡还是先有蛋）

因为结构体类型有重命名才能产生Node，而此时还未定义Node就在结构体内部使用了Node，所以会产生错误。

解决方案：

typedef struct Node

{

    int data;

    struct Node *next;

}Node;

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

有了结构体类型，那要怎么样来定义结构体变量和初始化变量呢？

例1：

struct Point

{

    int x;

    int y;

}p1;                //声明类型的同时定义变量p1

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

//初始化：定义变量的同时赋初值。

struct Point p3 = {x, y};

例2：

struct S //类型声明

{

    char name;//姓名

    int age;//年龄

    double d;//身高

    char sex;//性别

};

int main()

{

    struct S s = {'c', 20, 182.5, "boy"};//初始化

    return 0;

}

 例3：

#include

struct T

{

    double weight;//体重

    double height;//身高

}p;

struct S //类型声明

{

    char name;//姓名

    struct T p;

    short age;//年龄

    char sex[5];//性别

};

int main()

{

    struct S s = {'A', {63.5, 182.5}, 20, "boy"};//结构体嵌套初始化

    printf("%c %lf %lf %d %s\n", s.name, s.p.weight, s.p.height, s.age, s.sex);

    return 0;

}

四、结构体内存对齐

关于结构体的基本使用到这里我们就差不多掌握了。

现在我们深入讨论一个问题：我们都知道任何的数据类型都应有其对应的内存空间大小。如 char大小为1个字节，int 为4个字节，double 为8个字节等，如果无法确定大小，就无法在创建的时候知道该分配给该类型变量的内存空间是多少。

那么，结构体的大小是多少？又该如计算结构体的大小呢？ 

让我们来研究一下热门考点：结构体内存对齐

结构体的对齐规则

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

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

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

VS中默认的值为8

Linux中的默认值为4

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

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

练习1：

#include

struct s1

{

char c1;

int i;

char c2;

};

int main()

{

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

return 0;

}

执行结果：

分析：

练习2：

#include

struct s2

{

char c1;

char c2;

int i;

};

int main()

{

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

return 0;

}

执行结果：

分析：

 练习3：

#include

struct s3

{

double d;

char c;

int i;

};

int main()

{

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

return 0;

}

执行结果：

分析：

 练习4：

#include

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;

}

 执行结果：

分析：

为什么存在内存对齐?

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

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

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

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

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

例：

struct s1

{

char c1;

int i;

char c2;

};

struct s2

{

char c1;

char c2;

int i;

};

此时s1和s2类型的成员一模一样，但是s1和s2所占用的空间大小是有区别的，前者大小为12个字节，后者为8个字节，显然后者这种方式空间利用的效率更高。

修改默认对齐数

之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

#include

#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()

{

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

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

return 0;

}

执行结果：

分析：

由于s1的值我们之前已经知道了大小为12，那么我们来分析一下s2的值为什么是6？

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

百度笔试题

写一个宏，计算结构体中某变量相对于首地址的偏移，并给出说明

我们这边首先要用到宏，即 offsetof

#include

#include

struct s2

{

char c1;

int i;

char c2;

};

int main()

{

printf("%d\n", offsetof(struct s2, c1));

printf("%d\n", offsetof(struct s2, i));

printf("%d\n", offsetof(struct s2, c2));

return 0;

}

执行结果：

五、结构体传参

直接举例：

#include

struct S

{

int a;

char c;

    double d;

};

struct S s = { {1, 2, 3, 4}, 1000 };

void Init(struct S tmp)

{

tmp.a = 100;

    tmp.c = 'w';

    tmp.d = 3.14;

}

//结构体传参

void Print1(struct S tmp)

{

printf("%d %c %lf\n", tmp.a, tmp.c, tmp.d);

}

//结构体地址传参

void Print2(struct S* ps)

{

printf("%d %c %lf\n", ps->a, ps->c, ps->d);

}

int main()

{

    struct S s = {0};

    Init(s);

    Print1(s);//传结构体

print2(&s);//传结构体地址

return 0;

}

结构体传参有两种方式：

传递结构体对象（传值），对应的就是print1函数的方式

传递结构体地址（传址），对应的就是print2函数的方式

思考：上面的print1和print2函数哪个好些 ?

答案：首选print2函数。

原因：

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

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

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

六、结构体实现位段（位段的填充&可移植性）

结构体讲完就得讲讲结构体实现 位段 的能力。

什么是位段？

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

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

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

例： 

#include

struct A

{

int _a : 2;

int _b : 5;

int _c : 10;

int _d : 30;

};

int main()

{

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

return 0;

}

A就是一个位段类型。 那位段A的大小是多少呢？ 

执行结果：

位段的内存分配

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

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

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

而这些不确定因素体现在：

（1）空间是否要被浪费？

（2）空间是从左向右使用还是从右向左使用？

比如说VS2019：先开辟1 / 4个字节， 从右向左使用时，空间会被浪费

例：

#include

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;

}

思考：空间是如何开辟的？

执行结果（前）：

 执行结果（后）：

分析：

1）先开辟一个char类型大小的空间，也就是占用了1个字节。

2）将a的3个bit内容从右往左放入该字节中，此时还剩下5bit大小的空间

3）再将b的4个bit内容放到a的后面，此时还剩下1bit大小的空间

4）1bit空间内部不够c中5bit的内容存放，于是重新开辟了一个字节空间，从右往左后此时剩下了3bit大小的空间

5）剩下的空间(3bit)不够d的4bit内容存放，于是又重新开辟了一个字节空间，从右往左将d的4bit内容放进去

位段的跨平台问题

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

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

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

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

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

位段的应用

网络传输协议包（计算机网络）

我是小职，记得找我

✅ 解锁高薪工作

✅ 免费获取基础课程·答疑解惑·职业测评