自定义类型中的结构体+枚举

自定义类型

结构体

结构体的声明

struct Stu
{
	char name[20];
	int age;
	char sex[5];
	char id[20];
};

特殊的声明

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

struct {
	int a;
	char b;
	float c;
}x;

struct {
	int a;
	char b;
	float c;
}a[20],*p;

//上面的两个结构体在声明的时候省略了结构体标签(tag)

int main()
{
	p = &x;
	//上述代码是非法的，编译器会把上面两个声明当成完全不同的两个类型
	//即使内部的成员都相同
}

结构的自引用

struct Node {
	int data;
	struct Node next;
};
//这段代码是非法的，无法计算出结构体Node的大小
//Node类型中又包含了Node类型

//正确的自引用方式
struct Node
{
	int data;
	struct Node* next;
};
//合法，指针的大小是固定的

注意：

typedef struct
{
	int data;
	Node* next;
}Node;
//错误代码，typedef是先有类型之后重命名

typedef struct Node {
	int data;
	struct Node* next;
};
//正确格式

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

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

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

struct Point p3 = { 0,"han"};
//定义结构体变量p3同时赋初值

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

结构体内存对齐

• 结构体的对齐规则：

1.第一个成员在与结构体变量偏移量为0的地址处。
（偏移量即与结构体地址的距离，单位字节）
2.其他成员变量要对齐到对齐数的整数倍处的地址。
（对齐数即编译器默认的一个对齐数与变量的较小值）
（VS默认的值是8）
可以通过#pragma pack(8)来设置默认对齐数，括号中什么都不加表示还原成默认状态
3.结构体总大小为最大对齐数的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

• 了解了规则之后就可以解决下面的几个练习。

struct s1
{
	char c1;
	int i;
	char c2;
};
//结构体大小为
//1（char大小）+3(为了对齐不上的)+4(int大小)+1(char大小)+3(结构体对齐)=12

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

//结构体大小
//1+1+2+4=8

struct s3 {
	double b;
	char c;
	int i;
};
//结构体大小
//8+1+3+4=16

struct s4 {
	char c1;
	struct s3 s3;
	double d;
};
//结构体大小
//1+7+16+8=32
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));
}

• 为什么存在内存对齐

1.平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：
为了访问未对齐的内存，处理器需要作两次内存访问，而对齐的内存访问仅需要一次访问。
总体来说：内存对齐是拿空间来换取时间的做法。

• 所以在设计结构体时，我们既要满足内存对齐，又要节省空间，应该让占用空间小的成员尽量集中在一起，如：

struct s1
{
	char c1;
	int i;
	char c2;
};
//结构体大小 
//1+3+4+1+3=12

struct s2 {
	char c1;
	char c2;
	int i;
};
//大小为1+1+2+4=8

• offsetof计算结构体中某变量相对于首地址的偏移量

struct s3 {
	double b;
	char c;
	int i;
};
//结构体大小
//8+1+3+4=16

struct s4 {
	char c1;
	struct s3 s3;
	double d;
};
//1+7+16+8=32

int main()
{
	printf("%d\n", offsetof(struct s4, c1));//0
	printf("%d\n", offsetof(struct s4, s3));//8
	printf("%d\n", offsetof(struct s4, d));//24
}

结构体传参

传参时最好传结构体的地址，如果传结构体对象，空间开销较大

位段

• 位段的成员可以是int,unsigned int,signed int或是char类型
• 位段的成员名后边有一个冒号和数字。
• 位段的内存分配

位段的空间是按照4个字节或1个字节的方式来分配的。

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
struct S s = { 0 };

int main()
{
	s.a = 10;  //1010
	s.b = 12;  //1100
	s.c = 3;   //0011
	s.d = 4;   //0100
	printf("%d\n", sizeof(struct S));
	//此时S中的存储应该是0110 0010 0000 0011 0000 0100
	//                   6    2    0    3    0    4
	printf("%x", s);
}
//因为此时位段是char类型，每次分配一个字节
//一个字节中的八个bit从右向左使用，即后三位先给a使用，再给b使用
//不够使用时，再分配一个字节

• 位段的跨平台问题

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

枚举类型

枚举类型的定义

//enum Color
//{
//	RED,
//	GREEN,
//	BLUE
//};

//这些可能取值都是有值的，默认从0开始递增，一次递增1，也可以在定义时赋初值
//列如：

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

枚举的优点

1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较，枚举有类型检查，更加严谨。
3. 防止了命名污染（）
4. 便于调试，#define定义的常量在编译过程中就会被转换，无法在调试中看到。
5. 使用方便，一次可以定义多个常量。

枚举的使用

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

int main()
{
	enum Color clr = GREEN;
}