一:结构体的声明和使用:
声明:
struct tag{
member(成员);
};
struct stu{
char name[20];
int age;
//......可以有多变量
}
访问结构体变量成员及其结构体成员的初始化:
struct stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
};
int main()
{
struct stu s = { {"xiaoming"},{18},{"nan"},{"2022201"} };
struct stu* p = &s;
printf("%s\n", s.name);
printf("%d\n", s.age);
printf("%s\n", s.sex);
printf("%s\n", s.id);
printf("%s\n", p->name);
printf("%d\n", p->age);
printf("%s\n", p->sex);
printf("%s\n", p->id);
return 0;
}
结构体变量访问结构体变量使用“ . ”操作符访问,结构体指针变量使用“ -> ”来访问变量。
在声明结构体变量的时候,可以不完全声明,例如:
struct {
int age;
int id;
}s1;
struct {
int age;
int id;
}s2;
int main()
{
struct s1* p = &s1;
printf("%p\n", p);
return 0;
}
可以看到,编译器会报警告,会识别两个结构体变量为两个不同的类型,所以一般结构体不带标签声明只能使用一次。
结构体变量的自引用:
//链表节点定义
typedef struct Node
{
int data;
struct Node* next;
}Node;
int main()
{
Node s1;
s1.data = 12;
int ret = sizeof(s1);
printf("%d\n", ret);
return 0;
}
二:结构体内存对齐:
1.结构体内存对齐规则:
1.结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
2.其他成员变量要对⻬到某个数字(对⻬数)的整数倍的地址处。
对⻬数=编译器默认的⼀个对⻬数与该成员变量⼤⼩的较⼩值。
VS 中默认的值为 8
Linux中gcc没有默认对⻬数,对⻬数就是成员⾃⾝的⼤⼩
3.结构体总⼤⼩为最⼤对⻬数(结构体中每个成员变量都有⼀个对⻬数,所有对⻬数中最⼤的)的
整数倍。
先来看个程序:
struct s1 {
char i;
int j;
char k;
}s1;
struct s2 {
int j;
char i;
char k;
}s2;
int main()
{
int ret1 = sizeof(s1);
int ret2 = sizeof(s2);
printf("%d\n", ret1);
printf("%d\n", ret2);
return 0;
}
可以看到,就因为结构体成员防止顺序不同,大小也不同。
根据结构体内存对齐规则,我们通过下图来分析:
2.为什么存在结构体内存对齐:
1. 平台原因(移植原因):
不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定
类型的数据,否则抛出硬件异常。
2. 性能原因:
数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于,为了访问未对⻬的内存,处理器需要
作两次内存访问;⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节,则地
址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数,那么就可以
⽤⼀个内存操作来读或者写值了。否则,我们可能需要执⾏两次内存访问,因为对象可能被分放在两
个8字节内存块中。
总体来说:结构体的内存对⻬是拿空间来换取时间的做法
3.修改默认对齐数:
编译器的默认对齐数是可以修改的。
通过#pragma 来修改默认对齐数:之前的代码修改默认对齐数后。
#include<stdio.h>
//#pragma pack(2)
#pragma pack(1)
struct s1 {
char i;
int j;
char k;
}s1;
struct s2 {
int j;
char i;
char k;
}s2;
int main()
{
int ret1 = sizeof(s1);
int ret2 = sizeof(s2);
printf("%d\n", ret1);
printf("%d\n", ret2);
return 0;
}
#include<stdio.h>
#pragma pack(2)
//#pragma pack(1)
struct s1 {
char i;
int j;
char k;
}s1;
struct s2 {
int j;
char i;
char k;
}s2;
int main()
{
int ret1 = sizeof(s1);
int ret2 = sizeof(s2);
printf("%d\n", ret1);
printf("%d\n", ret2);
return 0;
}
还原编译器的默认对齐数:
#pragma pack()
括号里面什么都不加
#pragma pack(2)
//#pragma pack(1)
struct s1 {
char i;
int j;
char k;
}s1;
struct s2 {
int j;
char i;
char k;
}s2;
#pragma pack()
struct s3 {
char i;
int j;
char k;
}s3;
struct s4 {
int j;
char i;
char k;
}s4;
int main()
{
int ret1 = sizeof(s1);
int ret2 = sizeof(s2);
printf("%d\n", ret1);
printf("%d\n", ret2);
int ret3 = sizeof(s3);
int ret4 = sizeof(s4);
printf("%d\n", ret3);
printf("%d\n", ret4);
return 0;
}
应用场景:觉得结构体内存对齐不合适的时候可以修改结构体对齐大小,从而达到节约空间的目的。
三:结构体传参:
1.使用结构体变量传参:
2.使用结构体地址传参:
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(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s);
print2(&s);
return 0;
}
在函数传参传的是结构体的时候,两者都可以生效,但是由于在函数传参的时候,传递的是变量的时候会临时拷贝一份到函数内部,然而传递地址的就不用,所以一般结构体传参选用传递地址比较好,能够提升程序的效率,
四:结构体实现位段:
位段的声明和结构是类似的,有两个不同:
1. 位段的成员必须是 int、unsigned int 或signed int ,在C99中位段成员的类型也可以
选择其他类型。
2. 位段的成员名后边有⼀个冒号和⼀个数字,数字表示的单位是比特位(一个字节8个比特位)。
typedef struct s
{
int a : 4;
short b : 2;
long long c : 32;
}s;
1.位段的内存分配:
我们再VS中来调试一下看看内存布局:
结构体实现位段:注意:16进制来存储。
可以看到,使用位段来给结构体变量分配内存,在存储数据的时候数据存储在分配的内存中。
使用位段的注意事项:
1.在使用结构体位段的时候,给成员分配的内存不能高于其类型的大小。
例如:short类型的变量在使用位段分配内存的时候你给他分配了32个比特位,也就是4个字节是不可以的,short之后16个比特位,也就是2个字节。
2.位段不具备跨平台特性,可能因为不同的编译器产生不同的问题。