[C笔记]自定义类型：结构体(声明,自引用,传参,内存对齐,位段),枚举,联合

结构体

用于存放一组不同类型的数据。
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

结构体类型的声明

struct tag{
member-list;
}variable-list;//这个分号必不可少，结构体声明是一条语句

tag：结构体标签名。
member-list：结构体成员。
variable-list：定义结构体的同时可定义的结构体变量。如果不需要于别处再定义该结构体的变量且不需要自引用(见后文)，该结构体可以省略标签名。

注意：两个省略tag的匿名结构体就算成员相同也会被编译器当作两个不同的类型

结构的自引用

*在结构中包含一个类型为该结构本身的成员的地址
（若包含的是结构体本身的同类型的成员会无限递归）
*匿名结构体不可以自引用

常见于链表等

例：

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

结构体变量的定义和初始化

例1：

struct stu{
    char* name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在组
    float score;  //成绩
}st1,st2;//两个学生对应的结构体变量,不需要tag,全局

struct stu st3;//需要tag,全局

int main(){
	struct stu st4;//需要tag,局部
	return 0;
}

例2：

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

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

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

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

struct Stu s = {"LiTianSuo", 24};//初始化

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

struct Node n2 = {1919, {8, 10}, NULL};//结构体嵌套初始化

结构体传参

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

struct S{
	int data[100];
	int num;
};

struct S s = { {1,2,3,4},1000 };
	
void print1(struct S s){//结构体传参,别忘了struct关键字
	printf("%d\n", s.num);
}

void print2(struct S* ps){//结构体地址传参,别忘了struct关键字
	printf("%d\n", ps->num);
}

int main(){
print1(s); //传结构体
print2(&s); //传地址
return 0;
}

首选结构体地址传参。
原因：
函数传参时，参数需要压栈，会有时间和空间上的系统开销。
传递一个结构体对象时，若结构体过大，参数压栈的系统开销比较大，会导致性能下降。

结构体大小与内存对齐

使用sizeof求结构体大小时应注意别忘了struct关键字:

sizeof(struct 结构体变量名);

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

struct S1{
    char c1;
    int i;
    char c2;
};
struct S2{
    char c1;
    char c2;
    int i;
};
struct S3{
    double d;
    char c;
    int i;
};
struct S4{
    char c1;
    struct S3 s3;
    double d;
};

int main(){
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
    printf("%d\n", sizeof(struct S3));
    printf("%d\n", sizeof(struct S4));
    return 0;
}

输出：

内存对齐规则：

0.对齐数：

对齐数 = 编译器默认的对齐数 与 该成员大小 二者中的较小值。
VS默认以8字节对齐,而Liunx没有默认对齐数(也就是默认变量自身大小为对齐数)。

1.第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到对齐数的整数倍的偏移量处：
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果是嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

内存对齐原因：

1.平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：
为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。因此数据结构(尤其是栈)应该尽可能地在自然边界上对齐。

注意，内存对齐不是C语言的特性，它属于计算机的运行原理，C++、Java、Python等其他编程语言同样也会有内存对齐的问题。

修改默认对齐数

通常设置为2的整数次幂的值

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

#pragma pack(8)//设置默认对齐数为8
struct S1{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为编译器默认值

#pragma pack(2)//设置默认对齐数为2
struct S2 {
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为编译器默认值

#pragma pack(1)//设置默认对齐数为1(相当于不用对齐)
struct S3{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为编译器默认值

int main(){
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	printf("%d\n", sizeof(struct S3));
	return 0;
}

输出：

总结

总体来说，结构体的内存对齐是拿空间来换取时间的做法。
在设计结构体的时候，为实现既满足对齐，又节省空间的目的，应当把占用空间小的成员尽量集中在一起。

结构体实现位段

位段及其优缺点

位段（或称“位域”，Bit field）为一种数据结构，可以把数据以二进制位(bit)为单位紧凑地储存，并允许程序员对此结构的位进行操作。

1.位段的成员必须是 int、unsigned int 、signed int 或 char 。
2.位段的成员名后边有一个冒号和一个数字，该数字代表为该成员分配的二进制位数。

位段的优点：
-可以使数据单元的存储更节省空间。
-可以很方便地访问一个整数值的部分内容。
位段的缺点：
-跨平台移植存在障碍：位段内存分配与内存对齐的实现方式依赖于具体的硬件和系统，在不同的平台下可能有不同的结果，注重可移植性的程序应该避免使用位段：
1.int 位段会被当作有符号数还是无符号数是不确定的。
2.位段中最大位的数目不能确定（16位机器最大16bit，32位机器最大32，若写成分配27bit，在16位设备上会出问题）。
3.关于位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
4.不确定是否对齐：当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是占用之，是不确定的。

位段的内存分配

位段的空间是按照需求以4个字节（ int ）或者1个字节（ char ）为单位开辟的。

例(仅针对VS)：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

struct A{
	int a : 2;
	int b : 5;
	int c : 10;
	int d : 30;
};
//共分配了47个比特位，约6个字节。
//首先对于int类型的成员，开第一块4byte即32bit的空间，由a,b,c共占其中的17bit。
//然后d需要的空间大小超过第一块剩余的容量，便再开4byte即32bit的空间。
//至此，共需开辟8byte即64bit的空间。
//对于d放在这64个bit中的什么位置，是否对齐，标准并没有规定。

int main() {
	printf("%d\n", sizeof(struct A));
	return 0;
}

输出：

位段的应用

网络传输中用到的数据包封装等(可以有效提升带宽的使用效率)：

枚举

适合一一列举出来的元素会比较适合使用枚举
枚举可以通过定义有意义的常量名来避免直接使用数字编号表示“某个可能的情况”，且在有多个元素的场合要优于使用#define定义的标识符

枚举的优点：
1.增加代码的可读性和可维护性
2.枚举有类型检查，更加严谨(和#define定义的标识符相比)
3.防止了命名污染（封装）
4.便于调试
5.使用方便，一次可以定义多个常量

例：

enum Day{
Mon,//0为首元素默认对应值
Tues,//1
Wed,//2
Thur,//3
Fri,//4
Sat,//5
Sun//6
//注意最后一个枚举常量后面不接逗号
};

Day：枚举类型
Mon…Sun：枚举常量

枚举常量都有对应的值，默认从0开始，依次递增1
在定义时也可以指定初值：

enum Color{
RED=1,
GREEN=2,
BLUE=4
};

枚举的使用

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

enum Option{
	EXIT,//0
	ADD, //1
	SUB, //2
	MUL, //3
	DIV  //4
};

void menu(){
	printf("******************************\n");
	printf("**** 1. add     2. sub    ****\n");
	printf("**** 3. mul     4. div    ****\n");
	printf("**** 0. exit              ****\n");
	printf("******************************\n");
}

int main(){
	int input = 0;
	do{
		menu();
		printf("选择功能:>");
		scanf("%d", &input);
		switch (input){
		case ADD://相比使用0,1,2,3,4作为case，可读性更高了
			break;
		case SUB:
			break;
		case MUL:
			break;
		case DIV:
			break;
		case EXIT:
			break;
		}
	} while (input);
	return 0;
}

联合（共用体）

允许在相同内存位置的不同的时间上存储不同的数据类型。
可定义一个带有多成员的共用体，但是同一时刻只能有一个成员使用内存空间。
共用体提供了一种使用相同的内存位置的有效方式。

联合类型的定义

union Un{
char c;
int i;
};//联合类型的声明
union Un un;//联合变量的定义
printf("%d\n", sizeof(un));//输出联合变量的大小,结果为4

联合的特点

联合的成员是共用同一块内存空间的，因而一个联合变量的大小至少是最大成员的大小。

使用联合判断大小端

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

union U{
	char c;
	int i;
}u;

int main() {
	u.i = 1;
	if (u.c == 1){
		printf("小端\n");
	}
	else{
		printf("大端\n");
	}
	return 0;
}

联合大小的计算

联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
也就是说对于联合体，也存在内存对齐。

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

union Un1 {
	char c[5];
	int i;
};
union Un2 {
	short c[7];
	int i;
};

int main() {
	printf("%d\n", sizeof(union Un1));
	printf("%d\n", sizeof(union Un2));
	return 0;
}

输出：