自定义类型：结构体，枚举，联合

自定义类型：结构体，枚举，联合

本章重点

• 结构体
• 结构体类型的声明
• 结构体的自引用
• 结构体变量的定义和初始化
• 结构体内存对齐
• 结构体传参
• 结构体实现位段(位段的填充&可移植性)
• 枚举
• 枚举类型的定义
• 枚举的优点
• 枚举的使用
• 联合
• 联合类型的定义
• 联合的特点
• 联合大小的计算

#include<stdio.h>
struct Stu
{
	//成员变量
	char name[20];
	int age;
	float score;
}s1,s2;
//s1,s2为创建的全局的结构体变量
int main()
{
	return 0;
}

#include<stdio.h>
struct Stu
{
	//成员变量
	char name[20];
	int age;
	float score;
};
int main()
{
	struct Stu s;
	//s 和s1，s2一样，都是变量，只不过是s1，s2是全局的
	//但是像s1，s2那样的声明对象一般我们是不用的
	return 0;
}

特殊的声明—匿名结构体

匿名结构体的缺陷就是匿名结构体只能用一次，如下所示，只能用于声明变量s的那一次，之后就不能在用了，因为这个结构体是匿名的，是没有名字的

#include<stdio.h>
struct 
{
	//成员变量
	char name[20];
	int age;
	float score;
}s;
int main()
{
	return 0;
}

#include<stdio.h>
struct
{
	//成员变量
	char name[20];
	int age;
	float score;
}s;
struct
{
	//成员变量
	char name[20];
	int age;
	float score;
}*ps;
int main()
{
	ps = &s;
	return 0;
}

上述代码在vs下进行编译的时候是由警告的，如果编译器在严格一些的话，可能直接就出错了，出错的地方在于ps = &s，一般情况下来看，这个语句是没有问题的，因为是把结构体的地址赋值给了结构体指针类型，但是问题就在于上述的结构体是匿名的结构体，他是没有名字的，所以编译器在运行的是时候，就把他们当成了两部分了，所以自然会有警告的出现。

结构体自引用

#include<stdio.h>
struct Node
{
	int value;
	struct Node next;
};
int main()
{
	return 0;
}
//这样写代码可行吗？？

答案是不可行的，因为这样写代码的话，结构体的大小是无法计算的，因为我们并不知道next所代表的结构体的大小到底是多大，所以上述的代码是不可行的
，下面的代码是可行的

#include<stdio.h>
struct Node
{
	int value;
	struct Node *next;
};
int main()
{
	return 0;
}

这样子，结构体的大小就很容易能算出来了。

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

变量的创建

#include<stdio.h>
struct Point
{
	int x;
	int y;
};
struct Point p2;
int main()
{
	struct Point p1;
	return 0;
}

初始化

#include<stdio.h>
struct Point
{
	int x;
	int y;
};
struct Point p2 = { 2,3 };
int main()
{
	struct Point p1 = { 3,4 };
	return 0;
}

结构体内存对齐

#include<stdio.h>
struct S
{
	char c1;
	int a;
	char c2;
};
struct S2
{
	int a;
	char c1;
	char c2;
};
int main()
{
	printf("%d\n", sizeof(struct S));
	printf("%d\n", sizeof(struct S2));
	return 0;
}
//结果为12 和 8 

在结构体中求成员变量的偏移量可以使用offsetof

第一个成员相对起始位置的偏移量为0

函数原型

size_t offsetof( structName, memberName );
//头文件为<stddef.h>

offsetof传的是类型，然而函数是不能传类型的，所以说明了offsetof不是函数，offsetof是宏

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

模拟实现offsetof

地址和地址相减就是偏移量

#include<stdio.h>
struct S
{
	char c1;
	int a;
	char c2;
};
#define my_offsetof(s_type,member) (int)&(((s_type*)0)->member)
//把0地址强制类型转化成一个结构体指针，然后去访问成员，然后取地址，之后
//解引用就可以了
int main()
{
	printf("%d\n", my_offsetof(struct S, c1));
	printf("%d\n", my_offsetof(struct S, a));
	printf("%d\n", my_offsetof(struct S, c2));
	return 0;
}

结构体内存对齐

• 第一个成员在结构体变量偏移量为0的地址处
• 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处 对齐数=编译器的默认一个对齐数与该成员大小的较小值，VS中默认为8,linux下默认为4
• 结构体总大小为最大对齐数的整数倍
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍，结构体的整体大小就是所有最大对齐数的整数倍。

#include<stdio.h>
struct S3
{
	double d;
	char c;
	int i;
};
//16
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
//32
//从8开始放结构体3，从倍数开始放
int main()
{
	printf("%d\n", sizeof(struct S4));
	return 0;
}

为什么存在结构对齐呢？

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

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

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

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

修改默认对齐数

#include<stdio.h>
#pragma pack(2)  //设置默认对齐数为2
struct S
{
	int a;   //4 
	char c1;   //1 
	char c2;   //1 
	//一共6个字节大小
}; 
int main()
{
	printf("%d\n", sizeof(struct S));
	return 0;
}
//大小为6

#include<stdio.h>
#pragma pack(2)  //设置默认对齐数为2
struct S
{
	char c1;   
	int a;   
	char c2;   
	//一共8个字节大小
}; 
int main()
{
	printf("%d\n", sizeof(struct S));
	return 0;
}
//大小为8

默认对齐数一般都是偶数

取消默认对齐数
#pragma pack()

结构体传参

传结构体和传地址哪个会好一些？答案是传地址会好一些。如果结构体的成员很多的话，传结构体过去就会很浪费空间，所以传地址好一些，而且传地址可以把值也修改了。参数要压栈，会有时间和空间上的开销。

位段

什么是位段？

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

• 位段的成员必须是int，unsigned int或signed int
• 位段的成员名后面有一个冒号和数字
• 位段可以用户节省空间

#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;
}
//结果是8
//如果是int，首先先开辟4个字节的大小，也就是32个比特位
//用完了之后，在重新继续开辟就可以了
//一共开辟了两次，所以大小为8个字节

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
//需要3个字节的空间
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}
//先使用低处的比特位

位段的内存分配

• 位段的成员可以是int，unsigned int，signed int，char类型
• 位段的空间上是按照需要以4个字节(int)或者1个字节(char)的方式来开辟的
• 位段涉及很多的不确定因素，位段是不跨平台的，注意可移植的程序应该避免使用位段。

位段的跨平台问题

• int位段被当成有符号数还是无符号数这是不确定的
• 位段中最大位的数目不能确定
• 位段中的成员在内存中从左向右分配还是从右向左分配的标准还没有定义(讲的是先从右边开始分配)
• 当一个结构包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位的话，是舍弃还是继续利用的标准是不确定的

枚举

枚举顾名思义就是一一列举的意思

枚举是一种类型

枚举类型的定义：

#include<stdio.h>
enum Sex
{
	male,
	female
	//为sex所有可能的取值
};
int main()
{
	enum Sex sex = male;
	printf("%d\n", male);
	printf("%d\n", female);
	return 0;
}
//输出的结果为0和1，默认的是从0开始，但是值也是可以改的，如下所示：

#include<stdio.h>
enum Sex
{
	male = 5,
	female
	//为sex所有可能的取值
};
int main()
{
	enum Sex sex = male;
	printf("%d\n", male);
	printf("%d\n", female);
	return 0;
}
//打印的结果为5，6，一次向下加1 
//不是赋值，是给的初始值

我们可以使用#define 定义常量，为什么非要使用枚举呢，枚举的优点是什么呢？

枚举的优点

• 枚举是一种类型，而#define 是没有类型的，#define的类型检查不够严谨，而枚举类型相比之下就更加严谨了。
• 增加代码的可读性和可维护性
• 和#define定义的标识符比较枚举有类型检查，更加严谨
• 防止命污染(封装),与外界的冲突降低了 #define是全局的 ，枚举是在枚举内部的
• 便于调试
• 使用方便，一次可以定义多个常量

#include<stdio.h>
enum color
{
	RED = 1,
    GREEN=2,
	BLUE=4
};
int main()
{
	return 0;
}

enum Option
{
	ADD，
	SUB,
	MUL,
	DIV
};
int main()
{
	return 0;
}

预处理阶段会处理：

• #define
• #include
• #pragma

#define 定义的标识符常量是不便于进行调试的，它在预编译的时候就已经完成了值的替换，所以不方便。

编译(预编译，编译，汇编)，连接

联合体

联合体：联合体也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员共用一块空间(所以联合体也叫共用体)

#include<stdio.h>
union Un
{
	char c;
	int i;
	double d;
};
int main()
{
	union Un u;
	printf("%d\n", sizeof(u));
	return 0;
}
//大小为8

#include<stdio.h>
union Un
{
	char c;
	int i;
	double d;
};
int main()
{
	union Un u;
	printf("%d\n", sizeof(u));
	printf("%p\n", &u);
	printf("%p\n", &(u.i));
	printf("%p\n", &(u.c));
	printf("%p\n", &(u.d));
	return 0;
}
//地址一样，说明共同同一块空间

#include<stdio.h>
union Un
{
	char ch[5];
	int i;
};
int main()
{
	union Un u;
	printf("%d\n", sizeof(u));
	return 0;
}
//大小为8

联合体大小的计算

• 联合体的大小至少是最大成员的大小
• 当最大成员的大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

判断当前机器是大端还是小端

int check_sys()
{
	int a = 1;
	//01 00 00 00
	//00 00 00 01
	/*if(*(char*)&a == 1)
		return 1;
	else
		return 0;*/
	//返回1表示小端
	//返回0表示大端
	return (*(char*)&a);
}
int main()
{
	//int a = 0x11223344;
	//[11][22][33][44]-大端字节序存储
	//低     高
	//[44][33][22][11]-小端字节序存储
	if(check_sys()==1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

int check_sys()
{
	union
	{
		int i;
		char c;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	//int a = 0x11223344;
	//[11][22][33][44]-大端字节序存储
	//低     高
	//[44][33][22][11]-小端字节序存储
	if (check_sys() == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}