C语言-结构体

----------------------------

------------------

 岁月漫长心怀热爱，携手共赴星辰大海

--------今天来到我们自定义类型

-----结构体的讲解

---

目录

结构体的类型声明和初始化

结构体的类型声明

结构体成员的直接访问

结构体成员的间接访问

嵌套结构体进行访问

使用typedef来定义结构体

匿名结构体类型

结构体的自引用

qsort排序结构体

结构体的传参

结构体内存对齐 

为什么存在内存对齐?

#pragma改变编译器的默认对齐数

结构体实现位段

结构体位段的声明

位段的内存分配

位段的跨平台性

位段的运用

位段使用的注意事项

---

 

结构体的类型声明和初始化

结构体的类型声明

C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学生，描述⼀本书，这时单⼀的内置类型是不行的。描述⼀个学生需要名字、年龄、学号、身高、体重等；C语言为了解决这个问题，增加了结构体这种自定义的数据类型，让程序员可以自己创造适合的类型。

声明结构体类型时使用的关键字是struct，一般形式如下：

struct 结构体名
{成员列表
};

再声明结构体类型的时候不要忘记花括号后面的分号' ; '哦！

struct stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
}；

上面的代码用struct申明了一个名为stu的结构体类型，在结构体中定义的变量是stu结构体内部的成员，这些成员表示名字，年龄， 性别，学号，可以根据结构体成员中不同的作用选择与其相对应的类型。

struct stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
}s,t;

 以上是在声明结构体的同时定义了变量s，t

 结构体成员的直接访问

可以用struct+结构体名+变量名 = {成员列表};

对变量进行直接初始化 

#include<stdio.h>
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
};
int main()
{//按照结构体成员的顺序初始化struct Stu s = { "张三", 20, "男", "2023101314" };//按照自定义顺序初始化结构体成员struct Stu t = { .sex = "男",.name = "李四",.id = "2023105201",.age = 19 };printf("%s %d %s %s\n", s.name, s.age, s.sex, s.id);printf("%s %d %s %s\n", t.name, t.age, t.sex, t.id);return 0;
}

 也可以利用scanf函数进行输入：

#include<stdio.h>
struct Stu
{char name[20];int age;char sex[5];int id;
}s1;
int main()
{scanf("%s", s1.name);//数组可以不用取地址&符号scanf("%d", &s1.age);scanf("%s", s1.sex);scanf("%d", &s1.id);printf("%s %d %s %d", s1.name, s1.id, s1.sex, s1.age);return 0;
}

数组的前面可以不用取地址符号（&）

因为数组本身就是地址 

自定义初始化结构体成员只要 ' . ' 点一下就可以显示成员信息啦

结构体成员的直接访问是通过点操作符 ' . ' 访问的，点操作符接受两个操作数

使用方式：结构体变量.成员名  

 结构体成员的间接访问

我们可以用指向结构体的指针来访问成员变量

#include <stdio.h>
struct Point
{int x;int y;
};
int main()
{struct Point p = { 3, 4 };struct Point* ptr = &p;ptr->x = 10;ptr->y = 20;printf("x = %d y = %d\n", ptr->x, ptr->y);printf("x = %d y = %d\n", p.x, p.y);return 0;
}

1.我们这里定义了两个整形成员的结构体类型

2.并对结构体类型变量p成员赋值3，4

3.我们用指针ptr对结构体类型变量p取地址 

4.利用结构体指针操作符（->）对结构体成员进行访问

使用方式：结构体指针->成员名

#include <stdio.h>
#include <string.h>
struct Stu              //结构体类型
{char name[15];//名字int age; //年龄
};
void print_stu(struct Stu s)      //打印函数
{printf("%s %d\n", s.name, s.age);
}
void set_stu(struct Stu* ps)      
{strcpy(ps->name, "李四");//将李四拷贝到结构体变量的name的位置中ps->age = 28;           //利用指针访问结构体成员的age，并赋值
}
int main()
{struct Stu s = { "张三", 20 };print_stu(s);   //打印未拷贝前的结构体成员张三set_stu(&s);   //传址调用print_stu(s); //打印拷贝后的结构体成员李四return 0;
}

 嵌套结构体进行访问

当出现结构体嵌套时，必须以级联方式访问结构体成员，即通过成员选择运算符逐级找到最底层的成员时再引用 

#include<stdio.h>
struct Str
{int year;int month;int day;
};
struct Stu
{char name[20];int age;char sex[5];char id[20];struct Str date;
};
int main()
{struct Stu t = { .sex = "男",.name = "李四",.id = "2023105201",.age = 19 ,.date.year = 2023,.date.month = 12,.date.day = 1 };printf("%s %d %s %s %d-%d-%d\n", t.name, t.age, t.sex, t.id, t.date.year, t.date.month, t.date.day);return 0;
}

 使用typedef来定义结构体

typedef struct
{结构体成员列表;
}结构体别名;

与没有typedef的的定义的区别在于：

1.没有typedef的定义：struct Stu s = {结构体成员列表}；

2.typedef的定义：Stu s = {结构体成员列表}；

3.typedef可以省略struct这个关键字，做到简化代码

4.typede可以对匿名结构体重命名

typedef struct
{char name[30];int age[10];
}Stu;
int main()
{Stu s = { .name = "张三",.age = "18" };return 0;
}

 匿名结构体类型

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

#include <stdio.h>
struct
{int a;char name;int b;float score;
}x;
struct
{int a;char name;int b;float score;
}*p;
int main()
{*p = &x;return 0;
}

以上的结构体声明，省略了结构体名

假如我定义了两个相同结构体类型的变量x和指针p

那么我是否可以*p = &x呢？

答案是不可以的，因为结构体是匿名的，编译器会认为是两种不一样的类型

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

匿名结构体不建议大家使用的

不过也可以写来备用，到时候用typedef重命名就好啦

 结构体的自引用

在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？像以下代码

struct Stu
{int a;struct Stu;
};

答案是不可行的，结构体的自引用不像函数递归可以直接自己调用自己

如果上述代码可行的话，那么sizeof(struct Stu)的大小是多少呢

因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的大小就会无穷的大，是不合理的

所以要做到结构体的自引用，可以借用指针来实现

struct Stu
{int a;           //存放数据struct Stu* next;//存放下一个节点的地址//next-同类型的结构体指针
};

  

我们可以通过存放相同结构体类型的指针来完成自引用

这就是我们以后要学的数据结构中的链表

注意： 

在结构体自引用的时候最好不要使用typedef对匿名结构体重命名

就像以下代码是不可行的

typedef struct
{int a;Stu* next;
}Stu;

因为Stu是对前面的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使

用Stu类型来创建成员变量 ， 这是不行的

解决的办法是：要自引用时定义结构体不要使用匿名结构体 

typedef struct Stu
{int a;struct Stu* next;
}Stu;

 qsort排序结构体

我们之前说到qsort可以对任意类型的数据排序

接来我们将用它来排序结构体

void qsort (void* base, size_t num, size_t size, int (*compar)(const void*,const void*));

base首元素地址-数组名

num元素个数

size数据类型的大小

int (*compar)(const void*,const void*))比较大小的函数指针

 以下我用qsort排序结构体的名字：

#include<stdio.h>
struct Stu 
{char name[20];int age;
};
//strcmp-是库函数，是专门用来⽐较两个字符串的⼤⼩的（不懂可以看我之前的博客）
//假设按照名字来⽐较
int PaiXu(const void* e1, const void* e2)
{return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);//比较字符串的大小，返回>0或<0或=0的值
}
int main()
{struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };int rs = sizeof(s) / sizeof(s[0]);qsort(s, rs, sizeof(s[0]), PaiXu);for (int i = 0; i < rs; i++){printf("%s %d\n", s[i].name,s[i].age);}return 0;
}

这是从小到大排序，从大到小排序可以通过交换两个指针的位置实现

于是我们可以发现结构体按照名字比较最大是zhangsan，最小是lisi

 结构体的传参

 函数的传参我们学过两种：

1.传值

2.传址

#include<stdio.h>
struct Stu
{int a[1000];int num;
};
struct Stu s = { {1,2,3,4},1314 };
void Print1(struct Stu s)
{printf("%d %d\n", s.a[0],s.num);
}
void Print2(const struct Stu* s)   //用const加以修饰指针说明s不可修改
{printf("%d %d\n",s->a[0], s->num);
}
int main()
{Print1(s);  //传值Print2(&s); //传址return 0;
}

 以上我们发现无论是传值还是传址其结果都是一样的

但是空间、时间复杂度上是不一样的：

1.传值：比如说我结构体成员中定义了长度为1000的数组a[1000]，我的实参开辟了1000个存储空间，而传结构体的值过去我的形参也要开辟1000个存储空间，多的空间不用这就造成了空间上的浪费

2.传址：我们传结构体的地址过去，形参中就可以不用多开辟空间，效率就高。再加上可以利用const对结构体指针加以限制就可以避免对实参地址的破坏

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

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

所以我们一般选择传址调用~

结构体内存对齐 

首先得掌握结构体的对齐规则：

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

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

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

VS 中默认的值为 8

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

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

4. 如果嵌套了结构体的情况，嵌套的结构体成员对齐到⾃⼰的成员中最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍

我们来看以下代码： 

再没有学结构体内存对齐之前

大家对以下结构体的大小认识还不是还停留在：

两个char类型2个字节，一个int类型4个字节，结构体就是6个字节 

看看S1和S2的大小是多少？ 

#include<stdio.h>
struct S1
{char c1;int i;char c2;
};
struct S2
{char c1;char c2;int i;
};
int main()
{printf("%d\n", sizeof(struct S1));printf("%d\n", sizeof(struct S2));return 0;
}

我们发现S1和S2的大小并不是我们预想的6个字节

而是S1是12个字节，S2是8个字节

为什么呢？请你带着知识的困惑来看我们的结构体内存对齐：

以上是S1的情况，我们来看：

因为VS编译其中，默认对齐数是8，而(char)、(int)类型的大小是1和4

所以char的对齐数是1，int的对齐数是4，最大对齐数是4

char一个字节对齐起始位置偏移量为0的地址处

因为1到3地址不是int对齐数的整数倍所以要浪费空间

int要从4地址开始取地址，当char取了9地址的时候

由于结构体总大小要为最大对齐数的整数倍，所以要浪费空间到12地址

我们来看S2的情况：

因为VS编译其中，默认对齐数是8，而(char)、(int)类型的大小是1和4

所以char的对齐数是1，int的对齐数是4，最大对齐数是4

char一个字节对齐起始位置偏移量为0的地址处

因为2到3地址不是int对齐数的整数倍所以要浪费空间

int要从4地址开始取地址，取到8地址是结构体最大对齐数的整数倍

我相信聪明的你已经学会了，接下来看嵌套一个结构体的情况：

#include<stdio.h>
struct S2
{char c1;char c2;int i;
};
struct S4
{char c1;struct S2 s2;double d;
};
int main()
{printf("%d\n", sizeof(struct S2));printf("%d\n", sizeof(struct S4));return 0;
}

因为VS编译其中，默认对齐数是8

而(char)、(double)、（S2）类型的大小是1、8、8

所以char的对齐数是1，double、S2的对齐数是8，最大对齐数是8

char一个字节对齐起始位置偏移量为0的地址处

嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处

S2成员最大对齐数是4，所以1到3的空间要浪费，直到取到12地址

double要对齐所以要浪费13到15的空间，直到取到24

24是结构体最大对齐数的整数倍，所以结构体大小就是24

 为什么存在内存对齐?

平台原因：

不是 所有的硬件平台 都能访问任意地址上的任意数据 的

某些硬件平台只能在 某些地址处取某些特定类型的数据

否则抛出硬件异常

性能原因：

数据结构(尤其是栈)应该 尽可能地在自然边界上对齐 ：

原因在于， 为了访问未对齐的内存，处理器需要作两次内存访问 ；

而 对齐的内存访问仅需要⼀次访问 ；

符合的数据更快被CPU访问。

假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。

如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，

那么就可以⽤⼀个内存操作来读或者写值了。

否则，我们可能需要执行两次内存访问，

因为对象可能被分放在两个8字节内存块中。

 

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

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

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

就像我们刚刚写的代码，S2的大小是8，S1的大小是12

#include<stdio.h>
struct S1
{char c1;int i;char c2;
};
struct S2
{char c1;char c2;int i;
};
int main()
{printf("%d\n", sizeof(struct S1));printf("%d\n", sizeof(struct S2));return 0;
}

 #pragma改变编译器的默认对齐数

#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.位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以

选择其他类型，char比较常见

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

位段的作用：节省内存空间 

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

这时的A就是一个位段 

我们来看一下，struct A的大小是多少？

#include <stdio.h>
struct A
{int _a : 2;int _b : 5;int _c : 10;int _d : 30;
};
int main()
{printf("%d", sizeof(struct A));return 0;
}

首先我们要理解冒号后面的是什么

位段就是一个二进制位

冒号后面的数据的单位就是比特位 

我们发现strcut A的大小是8，那么8代表什么呢 ？

我们来看，如果冒号后面的数据单位是比特位的话

那么struct A的大小就是47个比特位

一个整形4个字节就是32个比特位不够

两个整形就是8个字节就是64个比特位

所以8代表8个字节

如果我们按照原始的方法存储的话，4个整形就是16个字节

而我们位段只需要8个字节就可以了，节省了内存空间 

 位段的内存分配

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

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

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

 所以位段很依赖编译器，我们来认识VS下的位段：

从右向左使用

如果剩余空间不够下一位成员使用就浪费

 位段的跨平台性

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

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

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

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

总结：

跟结构相比，位段可以达到同样的效果

并且可以很好的节省空间，但是有跨平台的问题存在

 位段的运用

能够对网络信息进行封装，从而提高运行效率。

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

 位段使用的注意事项

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

#incldue<stdio.h>
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;
}

通过本篇博客

我相信大家对C语言结构体都有了一定的理解

希望这些知识可以运用在你的实际生活中