C语言自定义类型之结构体

结构体

1  结构体的声明

1.1 结构的基础知识

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

我们在这里用数组来类比一下

数组：一组相同类型元素的集合。

1.2 结构的声明

struct people //people属于自定义，大家喜欢什么就可以设置什么
{
   member—list； //成员列表
}variable—list； //变量列表

我们来示范一下。假设我们声明一个学生

struct student
{ 
   char name[20];  //姓名
   int age;        //年龄
   char sex[5];    //性别
   float score;    //成绩
} S1,S2,S3;
//其中S1,S2,S3是三个结构体变量

1.3特殊的声明

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

比如：

//匿名结构体类型
struct     //struct后面没有名字
{
    int a;
    char b;
    float c;
}x;
//匿名结构体有一个特点，只能使用一次。

1.4 结构体的自引用

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

#include<stdio.h>
struct node
{
  int date; //数据
  strct node n; //下一个节点
};
int main()
{
   printf("%d\n , note");
   return 0;
}

 

上述代码正确吗？如果正确，那 sizeof(struct Node) 是多少？
仔细分析，其实是不⾏的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的⼤
⼩就会⽆穷的⼤，是不合理的。
正确的⾃引⽤⽅式：

struct Node
{
 int data;
struct Node* next;
}

在结构体⾃引⽤使⽤的过程中，夹杂了 typedef 对匿名结构体类型重命名，也容易引⼊问题，看看
下⾯的代码，可⾏吗？

typedef struct
{
int data;
Node* next;
}Node;

答案是不⾏的，因为Node是对前⾯的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使
⽤Node类型来创建成员变量，这是不⾏的.

解决⽅案如下：定义结构体不要使⽤匿名结构体了

typedef struct Node
{
int data;
struct Node* next;
}Node;

 1.5 结构体变量的创建和初始化

#include <stdio.h>
struct Stu
{
char name[20]; //名字
int age; //年龄
char sex[5]; //性别
char id[20]; //学号
};
int main()
{
//按照结构体成员的顺序初始化
struct Stu s = { "张三", 20, "男", "20230818001" };
printf("name: %s\n", s.name);
printf("age : %d\n", s.age);
printf("sex : %s\n", s.sex);
printf("id : %s\n", s.id);
//按照指定的顺序初始化
struct Stu s2 = { .age = 18, .name = "lisi", .id = "20230818002", .sex = "⼥
printf("name: %s\n", s2.name);
printf("age : %d\n", s2.age);
printf("sex : %s\n", s2.sex);
printf("id : %s\n", s2.id);
return 0;
}

 1.6结构体内存对齐 

 非常重要的知识

我们已经掌握了结构体的基本使⽤了。
现在我们深⼊讨论⼀个问题：计算结构体的⼤⼩。
这也是⼀个特别热⻔的考点： 结构体内存对⻬。

我们先来个例子：

#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;
}

在这里就会有个疑问，为什么我们结构体的成员一模一样而字节却不一样呢？

接下来为大家解释清楚

首先我们先了解一个函数   “offsetof”

这是一个宏，可以直接使用，作用是计算结构体成员相较于起始位置的偏移量。

我们画图来解释

在这里我们先来理解偏移量

假设我们创建一个s1，s1在内存中开辟的空间是从0开始，我们在这里把每个方格理解为一个字节，在这里我们假设0就是起始位置，那么方格标号为1的就是偏移量为1，以此类推。偏移量我们理解为距离起始位置的距离。

理解完偏移量我们再来理解offsetof,通过Cplusplus我们可以查到关于它的用法。

我们可以知道 offsetof( 类型，成员量）

那我们通过代码来计算一下它们的偏移量。

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

代码运行结果如下：

那我们就可以很好解释了我们还是通过画图来解释

图中灰色的部分就是为  C1  开辟的空间  因为是char类型所以是一个字节

       蓝色的部分就是为   i     开辟的空间   因为是int类型所以是四个字节

      橙色的部分就是为  C2   开辟的空间   因为是char类型所以是一个字节

那么又有一个疑问我们在上面运行时struct s1的大小是12，那这又是怎么回事呢？

其实也很简单我们还是通过画图来解释

其实在 C2 的后面又开辟了三个字节的空间（图中红色部分），但是这些空间是没有用的，没有存放任何的东西， 加上在C1 后面也开辟了三个字节的空间一共是六个字节的空间，浪费掉了。

同理struct S2也可以为大家展示出来

1.61 结构体内存对⻬规则

⾸先得掌握结构体的对⻬规则：
1.结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
2.其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
对⻬数=编译器默认的⼀个对⻬数与该成员变量⼤⼩的较⼩值。
 VS 中默认的值为 8
Linux中gcc没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩
3.结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的
整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构
体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

我们先来求一下对齐数（结构体中，是所有对齐数中的最大的那个的整数倍）

在这里我们之间展示结果，过程上面有介绍，double d 在这个结构体中的对齐数最大是8个字节，

整个结构体的总大小是16，是所有对齐数中的最大的那个的整数倍(两倍）。

在这里我们不由自主的会想为什么要对齐呢？ 

⼤部分的参考资料都是这样说的：
1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定
类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要
作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地
址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以
⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两
个8字节内存块中。
总体来说：结构体的内存对⻬是拿空间来换取时间的做法。

大家可能还是不太能理解，没关系我们还是通过画图来给大家解释。

假设我们创建一个结构体struct s在内存中呢为s开辟空间，char c  占据一个字节，int i占据四个字节。如上图所示，当我们没有对齐时我在访问的时候可能会出现一次访问我们不能拿出 i 中所有的数据。（32位机器中的字长是32位，就是读取数据读取32位，那么就会出现问题在读取 i 时需要读取两次）32位一次读取四个字节。

需要读取两次还要拼凑两次读取的内容很明显这是一个浪费时间的操作。

那么当我们对齐时会发生什么效果呢？我们还是通过画图来展示

当我们对齐之后，我们只需要一次就可以读取到 i, 尽管浪费了三个字节的空间，但是大大提高了效率。所以这是我们所提到的   总体来说：结构体的内存对⻬是拿空间来换取时间的做法。

但是一直这样浪费空间也不是个办法，有没有一个办法来解决或者缓解一下呢？

那在设计结构体的时候，我们既要满⾜对⻬，⼜要节省空间，如何做到：
让占⽤空间⼩的成员尽量集中在⼀起。

1.7修改默认对⻬

代码展示如下：

#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.8结构体传参

大家先看代码演示：

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;
}

上⾯的 print1 和 print2 函数哪个好些？
答案是：⾸选print2函数。
原因：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。
结论：结构体传参的时候，要传结构体的地址。

2.  结构体实现位段

2.1 什么是位段

位段的声明和结构是类似的，有两个不同：
1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以
选择其他类型。
2. 位段的成员名后边有⼀个冒号和⼀个数字.

⽐如：

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

A就是⼀个位段类型

那位段A所占内存的⼤⼩是多少？

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

2.2 位段的内存分配 

1. 位段的成员可以是 int   unsigned int   signed int 或者是 char 等类型?
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的⽅式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。

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

4.3 位段的跨平台问题

1. int?位段被当成有符号数还是⽆符号数是不确定的。
2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会
出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃
剩余的位还是利⽤，这是不确定的。
总结：
跟结构相⽐，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

以上就是今天的讲解了，后续会给大家带来⾃定义类型：联合和枚举。请持续关注

感谢你的观看

愿同你共同进步。