C语言自定义类型

在学习C语言的时候，它有很多的自定义类型，例如：结构体，枚举，联合。。。
这些类型在我们的日常使用的时候，或多或少的都会遇见到，下面就系统的介绍一下这几种类型。

一.结构体

1.结构体类型的声明：通俗点来说，结构就是一些值的集合，这些值称为成员变量，结构体的每个成员可以是不同类型的成员变量。

如下所示：

struct goods
{
	char name[20]	//商品的名字
	int size;		//商品的大小
	char id[20];	//商品的编号
};

结构体使用的时候也可以省略掉结构体的标签

struct 
{
	int a;
	char c;
	float f;
}name;

2.结构体自引用的书写形式

struct Node
{
	int data;
	Node* next; //这里必须加上*因为这是一个指针
};

也可以写成下面这样的代码

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

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

struct point
{
	int x;
	int y;
}p1;

struct point p1 = {x,y};

struct Node
{
	int data;
	struct point p;
	struct Node* next;
}n1 = {10,{4,5},nullptr};	//结构体嵌套初始化
strcut Node n2 = {20,{5,6},nullptr};

4.结构体内存对齐
当我们计算结构体的大小的时候，就必须要运用内存对齐规则

struct S3
{
	double d;  
	char c;   
	int i;
}; 

struct S4 
{ 
	char c1;  
	struct S3 s3;   
	double d; 
};

int main()
{
	printf("%d\n", sizeof(struct S3));	//16
	printf("%d\n", sizeof(struct S4));	//32
	system("pause");
	return 0;
}

5.结构体传参

struct S
{
	int data[1000];
	int num;
};
struct S s = {{1,2,3,4},10000};

void Print(struct S* ps)
{
	std::cout << printf("%d\n",ps->num);
}
int main()
{
	Print(&s); //传地址
}
//在这里为什么要传地址呢？
//因为在函数传参的时候，参数是需要进行压栈的，如果传递给一个结构体对象的时候，
//结构体过大，参数压栈的系统开销比较大，所有会导致性能的下降。
//所以结构体传参的时候要传地址。

6.位段

• 1.什么是位段？
  位段的声明和结构体是类似的，但是也有不同之处，主要有两点。
• （1）.位段的成员必须是int，unsigned int 或者 signed int。
• （2）.位段的成员名后面有一个冒号和一个数字。
  如下所示：

struct A
{
	int a:2;
	int b:5;
	int c:10;
	int d:30;
};
//A就是一个位段，那么位段A的大小是多少呢？
printf("%d\n",sizeof(struct A));

• 2.位段的内存分配
• （1）位段的成员可以是int，unsigned int ，signed int 或者是char类型。
• （2）位段的空间是按照需要以4个字节（int）或者1个字节（char）的方式来进行开辟的。
• （3）位段涉及很多不确定因素，位段是不跨平台的，主要可移植程序应该避免使用位段。

C语言标准规定，位域的宽度不能超过它所依附的数据类型的长度。通俗地讲，成员变量都是有类型的，这个类型限制了成员变量的最大长度，:后面的数字不能超过这个长度。
C语言标准还规定，只有有限的几种数据类型可以用于位域。在 ANSI C 中，这几种数据类型是 int、signed int 和 unsigned int（int 默认就是 signed int）；到了 C99，_Bool 也被支持了。
但编译器在具体实现时都进行了扩展，额外支持了 char、signed char、unsigned char 以及 enum 类型，所以上面的代码虽然不符合C语言标准，但它依然能够被编译器支持。

• 3.位段的跨平台问题
• （1）int 位段被当成有符号数还是无符号数是不确定的。
• （2）位段中最大位的数目不能确定（16位机器最大为16，32位机器最大为32）
• （3）位段中的成员在内存中是从左往右分配，还是从右往左分配不能确定。
• （4）当一个结构包含两个位段的时候，第二个位段比第一个位段要大，无法容纳第一个位段的时候，是舍弃第一个位段，还是利用，这是不能确定的。

二.枚举

1.枚举类型的定义

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fir,
	Sat,
	Sun
};
//上述定义的就是一个枚举类型，{}中的内容是枚举类型的可能用值，也叫做枚举常量
//这些在取值都是有值的，默认是从1开始，一次递增1，当然在定义的时候可以副赋初值。
enum Color
{
	Red = 1,
	Green = 2,
	Blue = 4
};

2.枚举的优点

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

3.枚举的使用

enum Color
{
	Red = 1;
	Green = 2;
	Blue = 4
};
enum Color clr = Green;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异

三.联合（共用体）

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

union Un
{
	char c;
	int i;
};
union Un u;
printf("%d\n",sizeof(u));//4

2.联合的特点
联合的成员是公用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小。

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

printf("%d\n", &(u.i));
printf("%d\n", &(u.c));

u.i = 0x11223344;
u.c = 0x55; 
printf("%x\n", u.i); 

3.联合大小的计算

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

union Un1 
{ 
	char c[5];  
	int i; 
}; 
union Un2 
{ 
	short c[7];  
	int i;
}; 
//下面输出的结果是什么？
int main()
{
	printf("%d\n", sizeof(union Un1));//8
	printf("%d\n", sizeof(union Un2));//16
	system("pause");
}

面试题：
1.结构体的内存对齐规则：

• 1.第一个成员在与结构体变量偏移量为0的地址处。
• 2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处
  对齐数 = 编译器默认的一个对齐数与该成员大小的较小值
  vs中默认的值是8，Linux中默认的值是4
• 3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
• 4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数的整数倍。（包含嵌套结构体的对齐数）

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

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

总体来说：结构体的内存对齐是拿空间换时间的做法。
我们在设计结构体的时候，既要满足内存对齐，又要节省空间，所以应该让占用空间小的成员集中在一起。

3.设计结构体的时候，既要满足内存对齐，又要节省空间，又该如何？

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

struct S1		//12
{
	char c1;
	int i;
	char c2;
};			
struct S2		//8
{
	char c1;
	char c2;
	int i;
}

S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别

• 2.修改默认对齐数

#pragma pack(5)
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()

#pragma pack(1)
struct S2
{
	char c1;
	int i;
	char c2;
};
#pragma pack()

int main()
{
	std::cout << sizeof(struct S1) << std::endl;
	std::cout << sizeof(struct S2) << std::endl;
	system("pause");
	return 0;
}

4.写一个宏，计算结构体中某变量相对于首地址的偏移，并给出证明

#define FIND(student, e) (size_t)&(((student*)0) - >e)

struct student
{
	int a;
	int b;
	char c[30];
	int d;
};

int main()
{
	FIND(student, a); //等于0
	FIND(student, b）;//等于4
}

• (student*)0 //表示将常量0强制转化为student*型指针所指向的地址,当然也可以x，只是到最后还要减去这个x的值
• ((student*)0)->e 表示在0地址处的结构体student的成员e
• &(((student*)0)- >e)//表示取结构体指针(student*)0的成员e的地址,因为该结构体的首地址为0,所以其实就是得到了成员e距离结构体首地址的偏移量.
• (size_t)//是一种数据类型,为了便于不同系统之间移植而定义的一种无符号型数据,一般为unsigned int