十九、自定义类型：结构体

1 结构体类型的声明

1.1 结构的声明

结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是不同类型的变量，其声明格式如下：

struct tag
{
 member-list;
}variable-list;

例如描述一个学生：

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}; //分号不能丢

1.2 特殊的声明

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

比如：

//匿名结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], * p;

上面的两个结构在声明的时候省略掉了结构体标签tag。

那么问题来了：

///在上面代码的基础上，下面的代码合法吗？
p = &x;

虽然结构类型的成员一模一样，但是编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。 匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使用一次，也就是说匿名的结构体类型只能在声明结构体的同时就把变量给创建好，在主函数中再创建变量时编译器就会报错。

1.3 结构的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？
比如，定义一个链表的节点：

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

上述代码正确吗？如果正确，那么sizeof(struct Node)的大小是多少？

仔细想想，就会发现如果一个结构体中再包含一个同类型的结构体变量，那么这个结构体的变量就会无穷的大，是不合理的。

正确的自引用方式：

struct Node
{
 	int data;//存数据
 	struct Node* next;//存下一个节点的地址
};

在结构体自引用的过程中，如果夹杂typedef对匿名结构体类型进行重命名，也容易引入问题，比如下面的代码：

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

由于Node是为了对前面的匿名结构体类型进行重命名而产生的，但是在匿名结构体的内部已经提前使用Node类型来创建成员变量，所以这是不可行的。

要想用typedef对结构体类型进行重命名，就不能使用匿名结构体。

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

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

和初始化数组类似，结构体变量的初始化也用{ }。

例：

struct Point
{
	int x;
	int y;
}p1; //声明类型的同时定义变量p1

struct Point p2; //定义结构体变量p2

//初始化：定义变量的同时赋初值。
struct Point p3 = { x, y };

struct Stu //类型声明
{
	char name[15];//名字
	int age; //年龄
};

struct Stu s = { "zhangsan", 20 };//初始化

struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化

struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化

除此之外，C99中还有用指示器初始化的方式，这种方式允许不是按照成员的顺序进行初始化。

struct Stu
{
	char name[15];
	int age;
};
struct Stu s = { .age = 20, .name = "zhangsan" };//初始化

3 结构体内存对齐

在理解结构体的内存对齐之前，我们先来看下面一段代码：

//代码的输出结果是什么
#include <stdio.h>
struct S1
{
	char c1;
	char c2;
	int a;
};
struct S2
{
	char c1;
	int a;
	char c2;
};
int main()
{
	struct S1 s1 = { 'a','b',1000 };
	struct S2 s2 = { 'a',1000,'b' };
	printf("%zd\n", sizeof(s1));
	printf("%zd\n", sizeof(s2));
    return 0;
}

输出结果：

明明两个结构体类型的成员一模一样，可为什么s1和s2的大小并不相同呢？

这就涉及到结构体内存对齐的问题。

3.1 对齐规则

结构体的对齐规则如下：

1. 结构体的第一个成员对齐到相对结构体变量起始位置偏移量为0的地址处。

2. 其他成员变量要对其到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数与该成员变量大小的较小值。

   VS中默认的值为8。

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

3. 结构体总大小为最大对齐数（结构体中每个成员变量都有一个对齐数，所有对齐数中最大的）的最小整数倍，这个最小整数倍要能够容纳所有成员。

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

知道了对齐规则，下面我们来对刚才的代码进行解析：

上面的例子中，很好地运用了规则1-3，要理解规则4，我们需要再举一个例子：

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

输出结果：

解析：

3.1.1 offsetof宏

实际上，在C语言中，offsetof宏可以计算结构体成员相较于起始位置的偏移量，要使用这个宏需要包含头文件<stddef.h>。

例：

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

输出结果：

可以看到，输出结果和图中所对应的偏移量相同。

3.2 内存对齐的原因

3.2.1 平台原因

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

3.2.2 性能原因

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

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

所以在设计结构体的时候，我们如果既要满足对齐，又要节省空间，就应做到：

让占用空间小的成员尽量集中在一起。

例：

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

上面的代码中，S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有所不同。

3.3 修改默认对齐数

#pragma这个预处理指令，可以改变编译器的默认对齐数。

例：

//代码输出的结果是什么？
#include <stdio.h>
#pragma pack(1)//设置默认对⻬数为1
struct S
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对⻬数，还原为默认
int main()
{
	printf("%zd\n", sizeof(struct S));
	return 0;
}

结构体在对齐方式不合适的时候，我们可以自己更改默认对齐数，一般设置为2的次方数比较好。

3.4 结构体传参

我们通过下面的代码来理解结构体传参的方式：

#include <stdio.h>
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函数。

原因： 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。 如果传递一个结构体很大的对象时，参数压栈的系统开销比较大，所以会导致性能下降。

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

4 位段

4.1 位段的定义

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

1. 位段的成员必须是int、unsigned int或signed int，在C99中位段成员的类型也可以选择其他类型（比如char）。
2. 位段的成员名后有一个冒号和一个数字。

4.2 位段的内存分配

位段内存分配的要点：

1. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（char ）的方式来开辟的。
2. 由于位段涉及很多不确定因素（比如是大端存储还是小端存储并不确定），所以位段是不跨平台的，注重可移植的程序应该避免使用位段。

例：

//位段A所占内存的大小是多少？
#include <stdio.h>
struct A
{
    int _a : 2;
    int _b : 5;
    int _c : 10;
    int _d : 30;
};
int main()
{
    printf("%d\n", sizeof(struct A));
	return 0;
}

输出结果：

解析：

#include <stdio.h>
struct A
{
    int _a : 2;//表示成员_a只占2个比特位
    int _b : 5;//表示成员_b只占5个比特位
    int _c : 10;//表示成员_c只占10个比特位
    int _d : 30;//表示成员_d只占30个比特位
    //一共占用了47个比特位
    //1个字节8个比特位，1个整型32个比特位，所以需要2个整型也就是8个字节才能容纳。
};
int main()
{
    printf("%d\n", sizeof(struct A));
	return 0;
}

从这里我们就可以发现，位段是站在节省内存的角度来考虑问题的。

那么位段内部每个成员的空间是怎么分配的呢？

由于位段不跨平台，所以下面的例子只能说明VS位段内存分配的模式：

#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;
    printf("%d\n", sizeof(struct S));
	return 0;
}

输出结果：

解析：

4.3 位段无法跨平台的原因

1. int位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大位为16，32位机器最大位为32，写成27，在16位的机器会出问题）
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

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

4.4 位段的应用

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

4.5 使用位段的注意事项

由于位段的几个成员共有同一个字节，而内存中每个字节只分配一个地址，一个字节内部的比特位是没有地址的，这样有些成员的起始位置并不是某个字节的起始位置，也就是说这些位置处是没有地址的，所以不能对位段的成员使用&操作符，也就是说不能使用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;
}