认识结构体 - 技术栈

一.结构体类型的声明

1.结构的声明

2.定义结构体变量

3.结构体变量初始化

[1. 结构体的值传递](#1. 结构体的值传递)

[2. 结构体的指针(地址)传递](#2. 结构体的指针(地址)传递)

一.结构体类型的声明

1.结构的声明

cpp 复制代码

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

tag 是结构体类型(标识符)，通常用来给结构体类型命名。

member-list 是结构体的成员列表，列出了结构体中包含的各个成员。

variable-list 是可选的(可以不写) ，指在定义结构体类型时，直接声明一个或多个该结构体类型的变量。

2.定义结构体变量

举个例子:

cpp 复制代码

struct Person {
    char name[50];
    int age;
    float height;
};

结构体类型声明后，可以使用该类型定义结构体变量：

cpp 复制代码

struct Person person1;
//person1是结构体类型变量
//这就是为什么我在前面介绍结构体时说variable-list 是可选的,我们可以在main()函数里边定义

这会创建一个 Person 类型的变量 person1，你可以通过 "." 操作符访问结构体的成员，亦或者直接：

cpp 复制代码

person1.age = 30;
person1.height = 1.75;
strcpy(person1.name, "Alice");

3.结构体变量初始化

续接上面:

我们在初始化的时候可以以两种方法初始化:

(1)按照结构体成员的顺序初始化

(2)按照指定的顺序初始化

cpp 复制代码

按照结构体成员的顺序初始化 
struct Person person1={"Alice",30,1.75};

//按照指定的顺序初始化 
struct Person person2={.name="zhangsan",.age=30,.height=1.75};

//打印
printf("%s\n", person1.name);
printf("%d\n", person1.age);
printf("%f\n", person1.height);

注意:第二种的结构体初始化使用了指定成员初始化的语法，该语法是 C99 标准引入的。如果你的编译器支持 C99 或更高版本，那么这种初始化语法是正确的,否则就是错误的，在我们常用的VS2022就是不行的。

4.结构体的特殊声明

声明匿名结构体

你可以直接声明一个匿名结构体并定义一个变量：

cpp 复制代码

struct {
    int x;
    int y;
} point;  // point 是一个匿名结构体变量

这里没有给结构体指定名字 (tag)，但声明了一个名为 point 的变量。你可以通过 point.x 和 point.y 来访问成员。
这种方式适合只需要使用一次结构体的情况，不需要在其他地方重复使用结构体类型。

我们这里看一例子：

cpp 复制代码

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

上⾯的两个结构在声明的时候省略掉了结构体标签（tag）。那么问题来了？

cpp 复制代码

//在上⾯代码的基础上，下⾯的代码合法吗？ 
p = &x;

答案是非法的。

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

匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使用⼀次。

C 语言要求结构体赋值时，类型必须完全匹配，匿名结构体由于没有类型名称（tag），因此不能跨定义赋值。

二.结构体对齐(重点难点)

1.结构体对齐规则

1 .结构体的第⼀个成员对齐到和结构体变量起始位置偏移量为0的地址处

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

-对⻬数=编译器默认的⼀个对齐数与该成员变量大小的较小值。

-VS 中默认的值为 8

-Linux中gcc没有默认对齐数，对齐数就是成员自身的大小

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

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

2.结构体对齐练习

(一)简单结构体对齐

我们来看一个例子:

cpp 复制代码

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

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

打印出来的结果是?

对于第一个结构体来说:

一个12个字节

对于第二个结构体:

一共8个字节

我们看一下在vs2022运行的结果:

显然和我们计算的一样

(二)嵌套结构体对齐

cpp 复制代码

struct S3
{
	double d;//double型占8个字节
	char c;
	int i;
};

struct S4
{
	char c1;
	struct S3 s3;
	double d;
};

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

对于上面代码我们容易算得s3的字节数为:16个字节

那s4怎么算?

这时我们就要用到规则4了。c1的一个字节加上，s3的16个字节就有17个字节了,然后根据规则4，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，也就是使用结构体S3里面的最大的结构体成员,即double d(8个字节),这时再用规则2,因为8和8一样大，则直接使用8对齐，显然最合适的是24个字节.

还剩一个double b没算,加上8个字节，一共32个字节。

再用规则3，最大的为8，恰好32也是8的倍数，刚刚合适，所以s4的计算结果为32个字节。

我们来看一下结果:

显然是对的。

3.为什么存在内存对齐

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

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

2. 性能原因

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。

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

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

让占⽤空间⼩的成员尽量集中在⼀起

就像我们一开始介绍的简单结构体对齐那样！

cpp 复制代码

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

他们两长的一样，但是占用字节空间却有了区别...

4.修改默认对齐数

#pragma这个预处理指令，可以改变编译器的默认对⻬数。

cpp 复制代码

#include <stdio.h>
#pragma pack(1)//设置默认对⻬数为1 
struct S
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的对⻬数，还原为默认 
int main()
{
 //输出的结果是什么？ 
 printf("%d\n", sizeof(struct S));
 return 0;
}

结构体在对⻬⽅式不合适的时候，我们可以⾃⼰更改默认对⻬数。

当然我们在处理恰当的时候，可以节省更多空间

三.结构体传参

1. 结构体的值传递

值传递是将结构体的副本 传递给函数。函数内对结构体的修改不会影响原始结构体的数据。

cpp 复制代码

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void printPoint(struct Point p) {
    printf("Point: (%d, %d)\n", p.x, p.y);
}

int main() {
    struct Point p1 = {10, 20};
    printPoint(p1);  // 值传递
    return 0;
}

结果为:

2. 结构体的指针(地址)传递

指针传递是将结构体的地址 传递给函数。函数内对结构体的修改将影响原始结构体的数据。

cpp 复制代码

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void modifyPoint(struct Point *p) {
    p->x = 30;
    p->y = 40;
}

int main() {
    struct Point p1 = {10, 20};
    modifyPoint(&p1);  // 指针传递
    printf("Point: (%d, %d)\n", p1.x, p1.y);  // 修改后的值
    return 0;
}

结果为:

3.两种传参方式，哪种更好?

答案是：指针(地址)传参更好。

原因：

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

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

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

四.结构体位段

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

1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以选择其他类型。

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

举个例子:

cpp 复制代码

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

A就是⼀个位段类型。那位段A所占内存的大小是多少？

咱接着往下看

1.位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char 等类型

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

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

我们再来看:

cpp 复制代码

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

假设在一个字节中，地址从右往左存储

具体如图:

在一个字节中如果剩下的比特位不够存放该数的二进制位，则系统会再开辟一个新的空间(如果是char那就开辟一个字节也就是8个比特位,如果是int型就开辟32个比特位也就是4个字节),并存储该数。

可以看到，一共开辟了24个比特位，也就是3个字节

2.位段的跨平台问题

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

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

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

当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利⽤，这是不确定的。

总结：

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

3.位段的应用

下图是网络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要几个bit位就能描述，这⾥使⽤位段，能够实现想要的效果，也节省了空间 ，这网络传输的数据报大小也会较小⼀些，对网络的畅通是有帮助的。

4.位段使用的注意事项

位段的几个成员共有同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。所以不能对位段的成员使用&操作符，这样就不能使用scanf直接给位段的成员输入值，只能是先输入放在⼀个变量中，然后赋值给位段的成员。

cpp 复制代码

struct A
{
 int _a : 2;
 int _b : 5;
 int _c : 10;
 int _d : 30;
};
int main()
{
 struct A sa = {0};
 scanf("%d", &sa._b);//这是错误的 
 
 //正确的⽰范 
 int b = 0;
 scanf("%d", &b);
 sa._b = b;
 return 0;
}