C语言进阶之路--自定义类型：结构体、枚举与联合（精通版）

嗨嗨大家好啊！今天带来的内容是：结构体、枚举与联合。话不多说，我们直接进入知识的海洋。

一、结构体

1 结构体的声明

1.1 基本概念

结构是一些值的集合，这些值称为成员变量。数组也是一些值的集合，两者的不同之处在于：结构的每个成员可以是不同类型的变量，数组是一组相同类型元素的集合。而结构的成员可以是标量、数组、指针，甚至是其他结构体。

1.2 结构的声明

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

tag是根据实际情况进行命名的，member-list是成员变量的列表，variable-list是变量列表。 

//例如描述一个学生：

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

s1,s2是用该结构体类型创建的变量，在主函数外部创建的变量是全局变量，在主函数内部创建是局部变量。

1.3 匿名结构体类型 

//我们还是以上面的代码为例：
struct      
{
   char name[20];//名字
   int age;//年龄
   char sex[5];//性别
   char id[20];//学号
}s1,s2；//分号不能丢

#include <stdio.h>
struct
{
	char a[20];
	int b[10];
}x;
struct
{
	char a[20];
	int b[10];
}a[20],*p;
int main()
{
	p = &x;
	return 0;
}

 编译上面的代码，编译器会出现如下警告 ：

这说明虽然这两个结构体成员相同，但编译器会把上面的两个声明当成完全不同的两种类型，所以是非法的。  

注意：匿名结构体只能使用一次，在创建时就要有变量，相当于全局变量。

2 结构的自引用 

 我们先来观察下面的（1）代码： 

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

通过这个代码，来提出一个问题：在结构中包含一个类型为该类型本身的成员是否可以呢 ？下面我们进入正题。

自引用方式：

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

如上（2）代码，结构体类型是 struct Node，里面的成员变量 struct Node* next 是一个指向struct Node类型数据的指针。下面以画图的形式便于大家理解它的存储结构：

该结构体包含的指针能找到本身类型的另外一个数据，实现了链表的功能，这便是结构的自引用。

现在回到刚刚提出的问题，在 （2）的代码中，结构成员使用指向 struct Node 类型的指针来找到相应数据，从而达到结构的自引用效果，也就是说，此时结构体成员的类型变为了struct Node *，不是struct Node；在（1）的代码中，结构体成员的类型与结构的类型相同，均是struct Node，这并不可行。

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

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

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

//初始化：定义变量的同时赋初值
struct Stu//类型声明
{
   char name[20];//名字
   int age;//年龄
};

struct Stus={"lisikui",20};//初始化

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

struct Node2={20,{5,6},NULL};//结构体嵌套

4  结构体内存对齐

让我们来思考一个问题：结构体怎样计算大小呢？

首先需要掌握结构体的对齐规则：

 1、第一个成员在结构体变量偏移量为0的地址处。

 2、其他结构体成员变量要对其到对齐数（编译器默认的对齐数与该成员类型大小的较小值）的整数倍的地址处。（vs的默认对齐数为8，部分编译器没有默认对齐数。默认对齐数可以通过预处理命令#pragma更改。）

 3、每个结构体大小总为该结构体最大对齐数的整数倍。

 4、在嵌套了结构体的情况下，嵌套的结构体对齐到自己最大对齐数的整数倍处，这个结构体的大小就是包括嵌套结构体的最大对齐数的整数倍。

或许文字描述难以理解，下面通过画图为大家解释：

 

 计算结构体大小：

第一个字节相对于起始的地址偏移量为0，后面依次+1，由对齐规则可知：c1大小为一个字节，在与结构体变量偏移量为0的位置；c2大小为一个字节，小于默认对齐数8，整数倍为1,放在与结构体变量偏移量为1的位置；i大小四个字节，小于默认对齐数8，整数倍为4，放在与结构体变量偏移量为4~7的位置；结构体总大小为最大对齐数（i的对齐数为4）的整数倍，即结构体总体大小为8个字节。

下面检验我们的偏移量计算是否正确

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

那么为什么会存在内存对齐这种现象呢？ 

  大部分的参考资料都是如是说的：

1. 平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常；

2. 性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

struct S
{
   char c;
   int i;
};
struct S s;

 在32位机器下，若无内存对齐，访问i则需要访问两次，有内存对齐时访问一次便可访问到i

 

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

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到让占用空间小的成员尽量集中在一起呢？默认对齐数是可以修改的，之前我们见过了#pragma这个预处理指令，这里我们便使用一下，可以改变默认对齐数。

未改变默认对齐数时： 

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

 

c：0；i：对齐数为8，8~15；最大对齐数：8；总体大小：16 

当我们改变默认对齐数时： 

#include<stdio.h>
#pragma pack(4)
struct S
{
	char c;
	double i;
};
int main()
{
	printf("%d\n", sizeof(struct S));
	return 0;
}

c：0；i：对齐数为4，4~11；最大对齐数：4；总体大小：12 

结论：当结构的对齐方式不合适时，我们可以自己修改默认对齐数。 

 5 结构体传参

#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;
}

选择传址调用的原因：

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

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

6 位段

6.1 位段的概念

C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为位段。

位段的声明和结构大致相同，有两个不同之处在于：

1、位段的成员名后面有冒号和一个数字（给该成员赋给的bit空间，当没有冒号和数字时，则会开辟这个类型相对应的字节空间）；

2、位段的成员类型只能是int，unsigned int，signed int，char。

//例如：
struct A
{
   //1byte=8bit
   int_a:2;
   int_b:5;
   int_c:10;
   int_d:30;
};

A的大小为：

printf("%d\n",sizeof(struct A));

6.2 位段的内存分配 

 内存的分配规则：

1、位段的成员类型只能是 int，unsigned int，signed int 或 char（属于整型家族）。

2、位段的空间开辟是以4个字节（int）或者1个字节（char）的方式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段

#include<stdio.h>
struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	printf("%d\n", sizeof(struct S));
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

下面来进行画图分析：

 

综上，在内存中开辟3个字节分别用来存放：62 03 04 

6.3 位段的跨平台问题 

1. int 位段被当成有符号数还是无符号数是不确定的；

2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题；

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义；

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

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

 二、枚举

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

把可能的取值一一列举

比如我们现实生活中：

一周的星期一到星期日是有限的7天，可以一一列举

性别有：男、女、保密，也可以一一列举

月份有12个月，也可以一一列举

1 枚举的定义 

#include<stdio.h>
enum Day
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
int main()
{
	printf("%d\n", Mon);
	printf("%d\n", Tues);
	printf("%d\n", Wed);
	printf("%d\n", Thur);
	printf("%d\n", Fri);
	printf("%d\n", Sat);
	printf("%d\n", Sun);

}

 

{ } 中的内容是枚举类型的可能取值，也叫枚举常量。这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值，若给Mon赋值为1，后面会自动增加。

2 枚举的优点 

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

枚举的优点：

1. 增加代码的可读性和可维护性；

2. 与#define定义的标识符比较枚举有类型检查，更加严谨；

3. 防止了命名污染（封装）；

4. 便于调试；

5. 使用方便，一次可以定义多个常量。

3 枚举的使用 

enum Color
{ 
	RED=1,
	GREEN=2,
	BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5;

三、联合（共同体） 

1 联合类型的定义

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

union Un
{
	char c;
	int i;
};
union Un un;
int main()
{
	printf("%d\n", sizeof(un));
	printf("%d\n", &(un));
 
	printf("%d\n", &(un.c));
	printf("%d\n", &(un.i));
 
}

 

上述代码所运行的结果说明它们的地址都是相同的，c和i在第一个字节上共用空间，有部分空间会重叠 。如下图：

2 联合的特点 

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

union Un
{
	char c;
	int i;
};
union Un un;
int main()
{
	printf("%d\n", &(un.c));
	printf("%d\n", &(un.i));
 
	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.i);
}

 

上述代码中44被修改成55，因此在改c的值的时候i的值也被改变 。

我们在上一篇文章：
http://t.csdnimg.cn/FBXYv
 中讲解了”如何判断当前计算机的大小端存储方式“，今天我们利用联合来学习第二种方法实现：

若返回1，则是小端存储；若返回0，则是大端存储，分析如下图：

int check_sys()
{
	union Un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
}

 

3 联合大小的计算 

 联合的大小至少是最大成员的大小

当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

 

//比如
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;
}

 

我们以Un1为例进行分析，联合（共用体）也存在对齐，联合最大成员的大小是5，而最大对齐数是4，此时最大成员大小（5）不是最大对齐数（4）的整数倍，因此要向后对齐到8 

 

 

   好啦~今天的分享就到这里啦，最后的最后我想对大家说：不必急功近利，因为付出总会有回报！如果你们觉得这篇文章对自己有帮助，记得给博主一个三连哈，你们的支持是我创作的最大动力！！望大家加油，不负自己！