C语言结构体

结构体是什么，为什么要有结构体

在C语言中给我们提供了一些数据类型，比如int,char,double,float等数据类型，但这些数据类型并不能够满足我们的所有需求，假如说我们要描述一个学生，或者一个商品，那这些数据类型肯定不够我们使用C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

结构体的访问操作符

现在我们来创建一个结构体，来描述一个学生，学生需要姓名，学号，班级，年龄等

# include<stdio.h>
struct student
{
	int age;
	char name[20];
	int class;
	int number;
};
int main()
{
	struct student zhangsan = { 18,"张三",1,23219900 };//按照顺序来初始化
	printf("%d\n%s\n%d\n%d\n",zhangsan.age,zhangsan.name,zhangsan.class,zhangsan.number);
	return 0;
}

这里我们用结构体来初始化并描述了一个学生张三的一些基本信息，这就是结构体的基本用法，其中我们对结构体成员进行访问的时候用到了.操作符结构体成员的直接访问是通过点操作符（.）访问的，点操作符接受两个操作数。第一个就是成员变量也就是zhangsan，第二个就是要进行访问的结构体成员如name,gae等
使⽤⽅式：结构体变量.成员名
(.)操作符是直接访问操作符，还有间接访问操作符(->)
使⽤⽅式：结构体指针->成员名
同时我们也可以按照自己的顺序进行初始化，不用按照结构体内指定的顺序就像这样

# include<stdio.h>
struct student
{
	int age;
	char name[20];
	int class;
	int number;
};
int main()
{
	struct student zhangsan = { .class= 1, .age= 18,.name = "张三",.number = 2321434};//按照指定顺序来初始化
	printf("%d\n%s\n%d\n%d\n",zhangsan.age,zhangsan.name,zhangsan.class,zhangsan.number);
	return 0;
}

结构体的特殊声明

在声明结构的时候，可以不完全的声明。就像下面

struct 
{
	int age;
	char name[20];
	int class;
	int number;
}zhangsan;

这里我们省略了结构体标签（tag)，这就是匿名结构体，这种结构体只能用一次，匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使⽤⼀次。

结构体的自引用

在结构中包含⼀个类型为该结构本⾝的成员，这就是结构体的自引用，来看看下面的代码

struct zhangsan
{
	int age;
	char name[20];
	int class;
	int number;
	struct zhangsan* n;
};

这里我们用了一个指针，来表示了一个结构体本身的成员，这种写法是正确的，还有一种写法，但这种是错误的

struct zhangsan
{
	int age;
	char name[20];
	int class;
	int number;
	struct zhangsan n;
};

这是为什么呢？是因为这个结构体里面又包含了一个同类型的结构体变量，这样会导致结构体无穷大，所以是不正确的，那为什么上面的就是正确的呢，那是由于我们把一个同类型的结构体变量一指针的形式表示出来，如果需要用到它就直接找到他的指针就可以了，一个指针占4字节或者8字节，就不会导致结构体无穷大，所以是正确的。
在结构体⾃引⽤使⽤的过程中，夹杂了 typedef 对匿名结构体类型重命名，也容易引⼊问题，看看下⾯的代码，可⾏吗？

typedef struct 
{
	int age;
	char name[20];
	int class;
	int number;
	struct zhangsan* n;
}zhangsan;

答案是不⾏的，因为zhangsan是对前⾯的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使⽤zhangsan类型来创建成员变量，这是不⾏的。
解决方案就是不要使用匿名结构体

typedef struct zhangsan
{
	int age;
	char name[20];
	int class;
	int number;
	struct zhangsan* n;
};

结构体的内存对齐

现在我们已经了解结构体的一些基本情况了，我们来看看一个重要的东西，叫结构体的内存对齐。
对齐规则
⾸先得掌握结构体的对⻬规则：

1. 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
2. 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
   对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。

• VS 中默认的值为 8
• Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

3. 结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构
   体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。
   如果没理解清楚，我们来看看下面代码并画图解释一下。

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

这里的答案是12，我们来看看下面图片

我们知道结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处，所以第一个char类型的元素就存在0字节处（char的大小为1字节）
为什么要跳过1,2,3这3个字节呢，就是因为这条规则其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。vs是8字节，这里面最大的元素是int 是4字节，所以对齐数是4字节。所以在存放int的时候就要求存放在4的整数倍所以从4字节处开始往后面存放存放到第七个字节，然后char就存放在第8字节，因为char的大小是1字节，对齐数也是1字节，最后补全4个字节就是因为结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的整数倍。所以最后答案是12字节。下面还有个练习和这种分析方式是一样的

struct S1
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S1));
	return 0;
}

接下来我们看看结构体嵌套

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

来看看这张图，就是对上面的画图讲解，对应这条规则如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。这里s3的·最大对齐数是8所以存放s3结构体的时候要从8的整数倍开始存放

为什么要有内存对齐

为什么存在内存对⻬?
⼤部分的参考资料都是这样说的：

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

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

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

这里他们两个结构体的含的成员组数量，和类型都是一样的，但S2会比S1要节省内存空间一些，按照上面的方法分析就可以看出来，我们先分析一下s1首先char存放在0地址处，然后要跳过3个地地址空间，在4地址处开始存放int在8地址处存放char c2。这里存放完之后我们的总共的大小就变成了9字节，与最大成员类型对齐之后，大小就变成12字节，
S2首先存放两个char占0和1最后在4地址处开始存放int存放完之后总大小就8字节，是最大成员对齐数的整数倍所以就不用多占内存。所以我们在设计结构体的时候尽量多去考虑像这种问题的情况，就可以节省内存。

修改默认对齐数

在C语言中我们有一个操作指令可以修改默认对齐数就是#pragma 这个预处理指令，可以改变编译器的默认对⻬数。

#include <stdio.h>
#pragma pack(1)//设置默认对⻬数为1
struct S
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的对⻬数，还原为默认

我们可以根据自身情况来设置默认对齐数。

结构体传参

我们来看看这段代码

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函数。
原因；
这里我们以两种形式来传递结构体，一种是把整个结构体传过去，另一种就只传指针，
有一个东西叫做函数栈帧的创建与销毁，我们在创建函数的时候会有一个过程叫做压栈的东西，，他会把要传的参数分配一个内存空间供给压栈使用，我们直接传结构体会把data[1000]这个大数组都压在上面，会极大的浪费内存空间结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。而第二个就只传指针压栈的空间就会小很多了
只传一个指针一般只占4或者8个字节。
所以我们要在结构体传参的时候，要传结构体的地址。

结构体实现位段

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

1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以
   选择其他类型。
2. 位段的成员名后边有⼀个冒号和⼀个数字。
3. 位段是专门来设计节省内存的，可以根据自己的需求来计算到底需要多少比特位。
   比如；

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

我们来看看A这个位段占的内存是多少

是8字节，为什么呢？来画图看看

这就是原因，如果我们不用位段来存储的话a,b,c,d每一个元素都要开辟32个比特位来存储相比之下就浪费太多了。

段位的跨平台问题

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

位段的应用

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

位段的注意事项

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

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

可以画个图来示范一下。

好了，到这里就结束了，如果有错误欢迎指正。