第十七讲：结构体
1.初始结构体
1.1结构体声明
struct tag
{
member-list;
}variable-list;
struct：结构体关键字
tag：结构体标签名，为自己定义
struct tag：结构体类型
member-list：结构体成员列表
variable-list：结构体创建的变量列表
比如我们要定义一个学生类型结构体：
//结构体的声明
struct Stu //定义一个学生结构体
{
//结构体成员列表：
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu1, stu2;//stu1和stu2为结构体变量列表
1.2结构体变量的创建和初始化
1.2.1结构体变量的创建
//结构体的声明
struct Stu //定义一个学生结构体
{
//结构体成员列表：
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu1, stu2;//stu1和stu2为结构体变量列表，这是创建结构体变量的一种形式
int main()
{
//struct Stu为结构体类型，创建了一个stu3结构体变量
struct Stu stu3;//创建结构体变量的第二种形式
//与stu1和stu2不同的是，stu3是一个局部变量，而stu1和stu2是全局变量
return 0;
}
1.2.2结构体变量的初始化
1.2.2.1普通初始化
//结构体的声明
struct Stu //定义一个学生结构体
{
//结构体成员列表：
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu1, stu2;
int main()
{
//按照结构体成员的顺序初始化
struct Stu stu3 = {"于文乐", "20231104001", 100};//大括号括起来
//进行打印
printf("name = %s ", stu3.name);
printf("mem = %s ", stu3.mem);
printf("score = %d\n", stu3.score);
//按照自己想要的顺序初始化
struct Stu stu4 = { .mem = "20231104002", .name = "张增伟", .score = 50 };
//进行打印
printf("name = %s ", stu4.name);
printf("mem = %s ", stu4.mem);
printf("score = %d\n", stu4.score);
//与stu1和stu2不同的是，stu3是一个局部变量，而stu1和stu2是全局变量
return 0;
}
1.2.2.2结构体数组
//结构体数组
struct Stu //定义一个学生结构体
{
//结构体成员列表：
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu[2] = { //此时，这个2可以省略
{ "于文乐", "20231104001", 100 },
{.mem = "20231104002", .name = "张增伟", .score = 50 }
};
int main()
{
//进行打印
printf("name = %s ", stu[0].name);
printf("mem = %s ", stu[0].mem);
printf("score = %d\n", stu[0].score);
//进行打印
printf("name = %s ", stu[1].name);
printf("mem = %s ", stu[1].mem);
printf("score = %d\n", stu[1].score);
return 0;
}
1.2.2.3结构体指针
//结构体指针
struct Stu //定义一个学生结构体
{
//结构体成员列表：
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu1 = { "于文乐", "20231104001", 100 }, * pstu1 = &stu1; //定义结构体指针的第一种形式
int main()
{
//定义一个结构体指针，存储的是结构体变量的地址
struct Stu* pstu2 = &stu1;//定义结构体指针的第二种形式
//使用结构体指针进行打印，第一种方法：使用*和.
printf("name = %s ", (*pstu2).name);
printf("mem = %s ", (*pstu2).mem);
printf("score = %d\n", (*pstu2).score);//.的优先级比*高，所以*pstu2必须放在一起
//使用结构体指针进行打印，第二种方法：使用->
printf("name = %s ", pstu2->name);
printf("mem = %s ", pstu2->mem);
printf("score = %d\n", pstu2->score);
return 0;
}
1.3typedef定义结构体
//typedef定义结构体
typedef struct Stu //定义一个学生结构体
{
//结构体成员列表：
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}Stu; //对结构体命名的第一种形式：直接进行命名
typedef struct Stu Stu;//对结构体命名的第二种形式：对结构体单独命名
int main()
{
Stu stu1 = { "于文乐", "20231104001", 100 };
//进行打印
printf("name = %s ", stu1.name);
printf("mem = %s ", stu1.mem);
printf("score = %d\n", stu1.score);
return 0;
}
1.4结构体的自引用
在结构体中包含一个类型为该结构体本身的成员是否可以呢？
比如：定义一个链表的节点:
//1.4结构体的自引用
struct Node
{
int data;
struct Node next;
};
答案是：不行的，因为Node在创建空间时，创建的Node next变量中还要再次确定一次next变量的空间，也就是说第一次创建的next变量的空间中要有着下一个next变量的空间，依次循环，它需要开辟的空间是无限大的，所以它是不合理的
正确的自引用方式：
struct Node
{
int data;
struct Node* next;
//创建一个4/8字节的指针变量，存储地址。就能指向自己的空间，就不必创建一个存储自己的变量了
};
但是在进行自引用的过程中，使用typedef关键字可能会造成错误：
//typedef联合自引用使用错误写法：
typedef struct
{
int data;
Node* next;
}Node;//这里会出现错误：未识别标识符Node
//因为在这里才刚定义了结构体变量的名称，而在上面就已经使用了，这显然是不合理的
//正确写法：
typedef struct Node
{
int data;
struct Node* next;
//在这里，使用结构体未定义的初始名称就可以了
}Node;
1.5结构体的特殊声明
在声明结构体时，也可以不完全声明：
//1.5结构体的特殊声明
//这个结构体被称为匿名结构体
struct
{
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu2, stu3;//这个结构体只能在此时创建结构体变量
int main()
{
struct stu1; //不能在这里创建结构体
return 0;
}
我们来分析下面的代码：
//这个结构体被称为匿名结构体
struct
{
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}stu1;
//此时我们创建一个结构体成员相同的结构体
struct
{
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
}* ps;
int main()
{
//既然这俩结构体的成员类型相同，那么这时我们能使用指针ps存储stu1变量的指针吗
ps = &stu1;
//这时会报警告：从“*”到“*”的类型不兼容
//因为没有了变量名，编译器会认为这俩结构体类型不相同，所以他俩的指针也是不相同的
return 0;
}
2.结构体内存对齐
了解了上面之后，我们来了解计算结构体的大小
2.1对齐规则
我们首先来看一下对齐规则：
- 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
- 其他成员变量要对⻬到某个数字（对齐数）的整数倍的地址处。
对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。
- VS 中默认的值为 8
- Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩
- 结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的
整数倍。- 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构
体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。
我们举例子来进行说明：
2.1.1练习1
//练习1
struct S1
{
char c1;
//1 8 1 - 对应0-1地址的空间
//1 8 1分别对应变量类型大小、默认对齐量、最小对齐量
int i;
//4 8 4 - 4-7
char c2;
//1 8 1 - 8-9
//所以一共是4+4+1 = 9个字节
//但是总字节数要是最大对齐量的整数倍，所以结果为12
};
int main()
{
printf("%zd\n", sizeof(struct S1));
}
这次我们画图来进行说明，下面就不再画图了：
2.1.2练习2
//练习2
struct S2
{
char c1;
//1 8 1
char c2;
//1 8 1
int i;
//4 8 4
//4 + 4 = 8是4的整数倍，所以结果为8
};
int main()
{
printf("%zd\n", sizeof(struct S2));
}
2.1.3练习3
//练习3
struct S3
{
double d;
//8 8 8
char c;
//1 8 1
int i;
//4 8 4
//最大对齐数为8
//8 + 4 + 4 = 16是8的倍数，所以结果为16
};
int main()
{
printf("%zd\n", sizeof(struct S3));
}
2.1.4练习4
//练习4-结构体嵌套问题
struct S4
{
char c1;
//1 8 1
struct S3 s3;
//16 8 8
double d;
//8 8 8
//最大对齐数为8
//8 + 16 + 8 = 32为8的倍数，所以结果为32
};
int main()
{
printf("%zd\n", sizeof(struct S4));
}
2.2为什么存在内存对齐
1.平台原因 (移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：
数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。
总体来说：结构体的内存对⻬是拿空间来换取时间的做法。
那么如何在设计结构体的过程中，既要满足对齐，又要节省空间：
让占用空间相同的成员尽量集中在一起
例如：
struct S1
{
char c1;
int i;
char c2;
};//结构体大小为4+4+4 = 12
struct S2
{
char c1;
char c2;
int i;
};//结构体大小为4+4 = 8
s1和s2的成员一模一样，但是s1和s2占用的空间不一样
2.3修改默认对齐数
我们可以使用#pragma这个指令修改编译器的默认对齐数（不需要引用头文件，它是一个预处理指令）
//修改默认对齐数
#pragma pack(1)//设置默认对⻬数为1
struct S
{
char c1;
int i;
char c2;
};//此时结果为1+4+1 = 6,不再是12了
#pragma pack()//取消设置的对⻬数，还原为默认
int main()
{
//输出的结果是什么？
printf("%zd\n", sizeof(struct S));
return 0;
}
3.结构体传参
//结构体传参
struct Stu
{
char name[20]; //名字
char mem[20]; //学号
int score; //成绩
};
void Print1(struct Stu pstu)
{
//进行打印
printf("name = %s ", pstu.name);
printf("mem = %s ", pstu.mem);
printf("score = %d\n", pstu.score);
}
void Print2(struct Stu* pstu)
{
//进行打印
printf("name = %s ", pstu->name);
printf("mem = %s ", pstu->mem);
printf("score = %d\n", pstu->score);
}
int main()
{
struct Stu stu = { "于文乐", "20231104001", 100 };
Print1(stu);
Print2(&stu);
return 0;
}
在上面的两个函数Print1和Print2中，相对比较好的是哪个：第二个，第二个传入的是地址，如果像Print1中那么传参，参数需要压栈，会有时间和空间上的开销，如果结构体中的参数占用空间很大的话，压栈的开销比较大，会导致性能下降
所以，结构体进行传参，最好传入结构体的地址
4.结构体实现位段
4.1什么是位段
位段的声明和结构体相似，有两个不同：
1.位段的成员必须是整形家族中的变量(int、unsigned int、signed int)，在C99标准中位段成员的类型也可以是其他类型
2.位段成员后边有一个冒号和数字，这个数字代表着成员变量在结构体中占用的bit位
比如：
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};
4.2位段的内存分配
对于下串代码，占用的字节大小为多少：
//位段的创建
struct A
{
char _a : 2;
char _b : 4;
char _c : 5;
char _d : 4;
};
int main()
{
struct A a;
printf("%zd\n", sizeof(a));
}
我们画图来解释：
总结：
位段的空间是按照需要以4个字节(int类型)或1个字节(char类型)来开辟的（练习中会看见）
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。
练习：
//位段的创建
struct S
{
//因为是char类型，1个字节1个字节进行开辟
char _a : 2;
char _b : 4;
//a和b用一个字节
char _c : 5;
//c用一个字节
char _d : 4;
//d用一个字节
};
struct A
{
//因为是int类型，4个字节4个字节进行开辟
int _a : 2;
int _b : 5;
//ab用一个字节
int _c : 10;
//c用两个字节
//abc一共占用17个比特位，相较于4个字节，还剩32-17 = 15个比特位，不够装下d
int _d : 30;
//所以d再开辟4个字节空间，在这4字节空间中存储d
};
int main()
{
struct S s;
printf("%zd\n", sizeof(s));//所以总共为3个字节
struct A a;
printf("%zd\n", sizeof(a));//所以总共为8个字节
return 0;
}
4.3位段的跨平台问题
- int 位段被当成有符号数还是⽆符号数是不确定的。
- 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会出问题。
例如：在16位平台上，int为两个字节，int _a : 20是不存在的- 位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
- 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利⽤，这是不确定的。
总结：
跟结构相⽐，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。
4.4位段的应用
下图是⽹络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要⼏个bit位就能描述，这⾥使⽤位段，能够实现想要的效果，也节省了空间，这样⽹络传输的数据报⼤⼩也会较⼩⼀些，对⽹络的畅通是有帮助的。
4.5位段使用的注意事项
位段中的成员可能共用一个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。
所以不能对位段的成员使⽤&操作符，这样就不能使⽤scanf直接给位段的成员输⼊值，只能是先输⼊放在⼀个变量中，然后赋值给位段的成员。例如：
//位段的赋值
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
struct A a;
scanf("%d", *(a._a));//这样写是错误的
//正确方法如下：
int d = 0;
scanf("%d", &d);
a._a = d;
return 0;
}
84
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
