C语言：结构体

在前面我们已经介绍了整形，浮点型，字符型，还介绍了数组，字符串。但是在实际问题中只有这些数据类型是不够的，有时候我们需要其中的几种一起来修饰某个变量，例如一个学生的信息就需要学号（字符串），姓名（字符串），年龄（整形）等等，这些数据类型都不同但是他们又是表示一个整体，要存在联系，那么我们就需要一个新的数据类型。

一.结构体类型的声明

1.结构的声明

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

//形式

struct tag

{

member-list;

}variable-list;

struct是结构体关键字

tag是结构体的标签名，是自定义的

（ struct tag就是结构体类型 ）

{}里面放的是成员列表

variable-list是变量

member-list是结构体成员

例如，我们描述一个学生的各种信息：

struct Student

{

char name[20];

char sex[5];

char id[20];

int age;

}; / /注意：分号不能丢

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

注意：

只有结构体变量才分配地址，而结构体的定义是不分配空间的

结构体中各成员的定义和之前的变量定义一样，但在定义时也不分配空间

结构体变量的声明需要在主函数之上或者主函数中声明，如果在主函数之下则会报错
为了访问结构的成员，我们使用成员访问运算符（.）/（->）。

引用形式：<结构体类型变量名> . <成员名>

指针类型 <结构体类型变量名> -><成员名>

cpp 复制代码

#include<stdio.h>
struct Student
{
	char name[20];
	char sex[5];
	char id[20];
	int age;
};
int main()
{
	struct Student s = { "张三" , "男" ,"123456789",18 };
	printf("%s %s %s %d", s.name, s.sex, s.id, s.age);
}

cpp 复制代码

#include<stdio.h>

struct S
{
	char id[20];
	int age;
};
int main()
{
	struct S s = { "123456789",18};
	struct S* a=&s;
	
	printf("%d", a->age);
}

当然，这是我们按照顺序进行初始化，如果我们不想按顺序进行初始化呢，其实我们只需 .成员名再赋值即可。

cpp 复制代码

#include<stdio.h>
struct Student
{
	char name[20];
	char sex[5];
	char id[20];
	int age;
};
int main()
{
	struct Student s = { .age=18,.name="张三",.sex="男",.id="123456789"};
	printf("%s %s %s %d", s.name, s.sex, s.id, s.age);
}

3.结构的特殊声明

在结构体中还有一种特殊的声明：匿名结构体类型：没有名字的结构体。

1.匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使用一次。

cpp 复制代码

#include<stdio.h>

struct
{
	char id[20];
	int age;
}s;
int main()
{
	s.age = 18;
	printf("%d", s.age);
	return 0;
}

我们发现它是可以正常输出18的，然而，在下面这张图片上我们发现我们重新赋的变量名，并没有被定义，所以如果没有对结构体类型重命名的话，基本上只能使用一次。

2.编译器会把上⾯的两个声明当成完全不同的两个类型，所以是非法的。

cpp 复制代码

#include<stdio.h>

struct
{
	char id[20];
	int age;
}s;

struct
{
	char id[20];
	int age;
}*p;
int main()
{
	p = &s; 
	return 0;
}

我们发现在编译其实，他告诉我我们类型并不兼容，说明我们创建的结构体指针和结构体并不相同。

4.结构的自引用

在我们定义了一个结构体后，我们是否能在这个结构体中，像是下面这种引用它本身呢？

cpp 复制代码

struct Node
{
 int data;
 struct Node next;
};
int main()
{
	sizeof(struct Node);
	return 0;
}

其实我们想一想，这样其实是不可以的，因为每当我们进入一次结构体就会调用它本身，这样无穷的循环下去，结构体变量的大小就会变得无穷大。所以这样的的自引用是不可以的，那我们该如何正确的自引用呢？

其实我们可以用指针来找下一个元素，而指针的大小无非是4或8个字节的大小。

cpp 复制代码

struct Node
{
 int data;
 struct Node* next;
};
int main()
{
	sizeof(struct Node);
	return 0;
}

然而，在结构体自引用使用的过程中，夹杂了 typedef 对匿名结构体类型重命名，也容易引入问题，我们看看下面这段代码。

cpp 复制代码

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

当然，这是不行的我们，在结构体中使用了Node的指针，但是，Node，是我们在这之后才定义的，所以我们无法在结构体中使用它，那么我们该如何去使用它呢，其实很简单只需要我们不使用

匿名结构体类型就行了。

cpp 复制代码

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

二.结构体内存对齐

现在，我们已经了解了结构体的使用，那么我们该开始计算结构体的大小了，那么对于存了多个不同类型的结构体我们该如何进行结构体的大小计算呢？其实计算结构体的大小是有规则的，那么让我们来了解一下结构体的对齐规则吧。

1.对齐规则

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

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

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

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

如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍。

我们来求一下这个结构体的大小

cpp 复制代码

#include<stdio.h>
struct S
{
	char i;
	int n;
	short m;
	int j;
};
int main()
{
	printf("%d", sizeof(struct S));
	return 0;
}

我们看到char i为第一位大小为1，根据规则第一位从偏移量为0的地方开始，第二位为int n大小为4，4小于vs规定的对齐数，所以对齐数变为4，而我们要存入n就要找4的倍数，所以n我们要从偏移量为4的位置存4位，第三位为short m大小为2，2小于vs规定的对齐数，所以对齐数变为2，我们要存入m就要找2的倍数,而偏移量为8的地方就是我们要存m的位置，最后int j的大小为4，4小于vs规定的对齐数，所以对齐数变为4，而偏移量为12的地方就是我们要存j的位置，最后我们存到了偏移量为15的位置，而0-15，大小为16，我们的最大对齐数是根据我们类型的大小决定的，所以我们的最大对齐数为4，而16为4的倍数，所以16就是结构体的大小。

嵌套了结构体的情况：

cpp 复制代码

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

其实他跟上面是一样的，只是我们要求出S1的最大对齐数之后，在跟S2中的数据进行比较求出S2的最大对齐数。

2.为什么存在内存对齐?

平台原因 (移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。假设一个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作来读或者写值了。否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。

例如，在32位的机器上，数据总线是32根，读/写数据的时候，一次就读/写32个比特位（4字节）我们来看一下这段结构体对其和未对齐的状态
cpp 复制代码
struct S
{
	char c;
	int i;
};
我们发现未对齐的比起对齐的更加的节省了空间，但是由于我们读/写数据的时候（32位)，我们是一次性读取4个字节。我们来看看对齐和未对齐的读取情况吧

我们发现同样是读取两次，但是对齐后的直接就能找到，而未对齐的，在读取完后，我们需要两次读取完后才能找到i,所以我们发现如果我们牺牲一些空间后我们读取的效率反而提高了。

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

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

其实，我们只需要让占用空间小的成员尽量集中在⼀起

cpp 复制代码

//例如：
struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
};

S1 和 S2 类型的成员一模一样，但是 S1 和 S2 所占空间的大小有了一些区别，S1的大小为9，而S2的大小为8，所我们发现如果将占用空间小的成员集中在一起，就会使这个结构体相较于其他的成员一样的，但不是一样放置的大小要小，更加的节省空间。

3.修改默认对齐数

当然，关于结构体的存储，我们需要用到对齐数，如果我们将默认的对齐数进行修改，我们就可以改变他的对其方式。

修改对齐数的方法：

#pragma pack(对齐数)

我们只需要在括号中输入我们想要的对齐数就可以修改了。当然如果我们想要便会原对齐数数只需要在写一遍**#pragma pack()**

cpp 复制代码

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

cpp 复制代码

#include<stdio.h>
struct S
{
	int data[1000];
	int num;
};
//结构体传参
void print1(struct S s)
{
	printf("%d\n", s.num);
}
int main()
{
	struct S s = { {1,2,3,4}, 1000 };
	print1(s);
}

2.结构体地址传参

cpp 复制代码

#include<stdio.h>
struct S
{
	int data[1000];
	int num;
};
//结构体地址传参
void print1(struct S* s)
{
	printf("%d\n", s->num);
}
int main()
{
	struct S s = { {1,2,3,4}, 1000 };
	print1(&s);
}

我们发现结构体传参其实是有两种方式结构体传参和结构体地址传参，那么这两种方式，哪一种方式最好呢？，其实我们首选是用结构体地址传参。

原因：

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

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

其实就是结构体的传参后，之后被调用时会开辟新的空间，导致空间和时间上的开销变大，但是如果使用结构体地址传参，就不会开辟新的空间，而是直接调用结构体的地址，不会开辟新的空间。

结论：结构体传参的时候，要传结构体的地址。

四. 结构体实现位段

1.什么是位段

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

1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以选择其他类型。

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

cpp 复制代码

struct S
{
	int i : 4;
	int j : 5;
	int n : 20;
	int m : 25;
};

其实就是改变变量所占的比特位，例如将i位段后i就占了4个比特位 .

那么我们经过位段之后，他的结构体大小是多少呢？

这就涉及到了位段的内存分配

2.位段的内存分配

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

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

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

以vs平台为例：

cpp 复制代码

#include<stdio.h>
struct S
{
	int i : 4;
	int j : 5;
	int n : 20;
	int m : 25;
};
int main()
{
	printf("%d", sizeof(struct S));
}

我们知道int占四个字节32个比特位，如下图我们发现i，j，n，m.存放是从后往前的存放(在不同的平台下存放的方式可能是不一样的)，如果比特位不足(剩余的比特位不足将剩下变量完全存入，当然不同的平台存入的规则可能不一样)，就会根据类型开辟新的字节空间，所以我们发现他的大小为8个字节的大小。

虽然我们已经了解了他的开辟方式，但我们还是来验证一下他的开辟方式吧！我们以下面的代码为例子

cpp 复制代码

#include<stdio.h>
struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

我们现在将所有的数值赋为0，我们知道char类型占一个字节，所以我们会先开辟一个字节的空间8个bit位，首先我们知道a占3个bit位,b占4个bit位，他们可以存放到一个字节里，但是c占5个bit位，而我们剩1个bit位，所以我们会舍弃这个bit位，去开辟一个新的字节空间去存放c,存完c后我们剩3个bit位，但是d占4个bit位，所以我们再次舍弃这3个bit位去开辟新的字节空间去存放d.所以最后我们占据了3个字节的空间，并且存放是从右向左的存放。

但是我们要如何验证他呢？其实我们只需要将他进行赋值即可，将值存入其中，最后用16进制的形式查看它。

cpp 复制代码

int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

a=10,二进制为1010，但a占3bit位，所以存3位即010， b=12,二进制为1100，b占4bit位，所以存4位即1100, c=3,二进制为0011，但c占5bit位，所以存5位即00011, d=4,二进制为0100，d占4bit位，所以存4位即0100.之后我们知道四个二进制位转换1个16进制位，最后我们得到的16进制的值

我们来运用调试来看一下我们的想法是否正确。

未赋值前全为0

赋值后16进制的值

我们发现与我们得到一样所以在VS平台下我们的想法是正确的。

3.位段的跨平台问题

其实，位段是存在跨平台问题的，在不同的平台下，位段的规则是不一样的。

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

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

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

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

总结：跟结构相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

4.位段使用的注意事项

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

好了今天我们的讲解就到这里吧，我们下一篇见。