结构体就只是结构体吗?

学习重点

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

---

在我们学习C语言的过程中,我们提到过内置类型与自定义类型.

内置类型:

• char
• short
• int
• long
• long long
• float
• double

自定义类型

• 结构体
• 枚举
• 联合体

1.结构体

1.结构体的声明

1.1 结构的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

1.2 结构的声明

struct 结构体名 
{ 
   结构体成员列表->成员变量 
}变量列表；

举例1:一个关于学生的结构体

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
};

举例2:

struct Stu
{
	char name[20];
	char sex[5];
	int age;
	int hight;
}s2, s3, s4;//s2,s3,s4全局变量

struct Stu s5;//也是结构体变量

int main()
{
	struct Stu s1;//结构体类型创建结构体变量

	return 0;
}

1.3 特殊的声明

不完全声明—匿名结构体类型

struct
{
	char c;
	int a;
	double d;
}sa;//只能在这⾥创建，只能⽤⼀次

struct
{
	char c;
	int a;
	double d;
}*ps;//匿名结构体类型的指针


int main()
{
	//编译器认为等号两边时不同的结构体类型，所以这种写法时错误的
	ps = &sa;

	return 0;
}

1.4 结构的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

struct Node
{
	int data;//4
	struct Node next;//结构体对象-err
};

正确方式:

struct Node
{
	int data;
	struct Node* next;//结构体指针可以，存放地址需要⽤指针
};

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

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

int main()
{
	//两种初始化⽅法
	struct Node n2 = { 0 };
	Node n = { 0 };
	return 0;
}

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

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

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

struct Stu//类型声明
{
	char name[15];//名字
	int age;      //年龄
};
struct Stu s = { "zhangsan", 20 };//初始化

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

struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化

结构体的使用:

#include <stdio.h>

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

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

struct Data
{
	struct Stu s;//结构体包含结构体
	char ch;
	double d;
};

int main()
{
	struct Node n2 = { 100, NULL };
	struct Stu s1 = { "zhangsan", "nan", 20, 180 };
	struct Data d = { {"lisi", "nv", 30, 166},'w', 3.14 };
	//结构体包含结构体的初始化

	return 0;
}

1.6 结构体内存对齐

学习结构体内存对齐的目的就是计算结构体大小.那么我们来学习一下结构体的对齐规则;

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

• VS中默认的值为8
• Linux环境下没有默认对齐数,对齐数就是成员自身的大小

3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
   体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

那么,我们做几道练习来巩固一下吧!

练习1:

#include <stddef.h>
struct S1
{
	char c1;//1
	int i;//4
	char c2;//1
};//12


int main()
{
	struct S1 s;
	printf("%d\n", sizeof(struct S1));//12
	//printf("%d\n", offsetof(struct S1, c1));//0
	//printf("%d\n", offsetof(struct S1, i));/4
	//printf("%d\n", offsetof(struct S1, c2));//8

	return 0;
}

练习2:

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

int main()
{
	struct S2 s;

	printf("%d\n", sizeof(struct S2));//8
	return 0;
}

练习3:

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

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

练习4:

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

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

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

//如果嵌套了结构体的情况，嵌套的结构体对⻬到⾃⼰的最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数(含嵌套结构体的对⻬数)的整数倍。

练习5:

struct S
{
	char c1;//0
	//1~7
	double d;//8,8->8 8~15
	char c2;//16 0~16总共17个字节,不是8的倍数
	//17~23
};//24

int main()
{
	printf("%d\n", sizeof(struct S));//24 0~23
	return 0;
}

那么我们思考一下,为什么要存在内存对齐?

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

2. 性能原因:
   数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问;⽽对⻬的内存访问仅需要⼀次访问。

   

总而言之:结构体的内存对齐是拿空间来换取时间的做法。

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

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

//例如：
struct S1
{
	char c1;
	int i;
	char c2;
};//12
struct S2
{
	char c1;
	char c2;
	int i;
};//8
//S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

1.7 修改默认对齐数

#pragma pack(1)//修改默认对⻬数
struct S1
{
	char c1;//0       0
	int i;//4,1->1    1~4   ->6 是1的倍数->6
	char c2;//1,1->1  5
};//6
#pragma pack()//取消修改的默认对⻬数


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

#pragma pack(4)
struct S
{
	char c1;//0
	//1~3
	double d;//8,4->4 4~11
	char c2;//12 0~12->13个数,不是4的倍数
	//13~15
};//16
#pragma pack()

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

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。一般改成2^n

1.8 结构体传参

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); //传地址 更快速,但是加const也会变得更安全
	return 0;
}

上面的代码中,print2更好一些.

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

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

2.位段

2.1 什么是位段

位段一定程度上节省了空间

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

1. 位段的成员必须是 int、unsigned int 或signed int 。(写成char也没什么问题)
2. 位段的成员名后边有一个冒号和一个数字。

举个例子:

#include <stdio.h>
struct A
{
	int _a : 2;//2-需要2个⽐特位
	int _b : 5;//5-需要5个⽐特位
	int _c : 10;//10-需要10个⽐特位
	int _d : 30;//30-需要30个⽐特位
};
int main()
{
	printf("%d\n", sizeof(struct A));//8
	return 0;
}
//疑惑点：2 + 5 + 10 + 30 = 47，6byte * 8bit = 48bit，需要6个字节就够了啊？为啥是8个字节

2.2 位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。(意思就是先开4byte,也就是先开32bit用着)
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

举个例子:

struct A
{
	//4byte - 32bit
	int _a : 2;//30 _a的取值：00 01 10 11
	int _b : 5;//25
	int _c : 10;//15 不够30⽤了，在开辟4byte
	//4byte -32bit
	int _d : 30;
};
//歧义：_d到底只⽤了新开辟的4byte还是连着之前的也⽤了？
//C语⾔未定义的⾏为
//先开4byte，也就是先开32bit⽤着

//假设浪费 - 开辟3个字节
struct S
{
	//1byte-8bit
	char a : 3;//5
	char b : 4;//1
	//1byte-8bit
	char c : 5;//3
	//1byte-8bit
	char d : 4;//
};

//假设不浪费 - 开辟2个字节
struct S
{
	//1byte-8bit
	char a : 3;//5
	char b : 4;//1
	//1byte-8bit
	char c : 5;//4
	char d : 4;//
};
int main()
{
	printf("%d\n", sizeof(struct S));//3->浪费

	return 0;
}

2.3 位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
   器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
   舍弃剩余的位还是利用，这是不确定的。(浪费与不浪费的问题)

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

2.4 位段的应用

3.枚举

枚举->一一列举

3.1 枚举类型的定义

#include<stdio.h>

enum Day
{
	//枚举的可能取值
	Mon,
	Tues,
	Wed,
	Thir,
	Fri,
	Sta,
	Sun
};

//enum Sex
//{
//	MALE,//0
//	FEMALE,//1
//	SECRET//2
//};
//可以理解为与#define作用相同
//#define MALE 4
//#define FEMALE 5
//#define SECRET 6

typedef enum Sex
{
	MALE = 4,
	FEMALE = 8,
	SECRET//9
}Sex;

int main()
{
	//MALE = 6；//err
	//类型创建变量
	enum Day d = Sun;
	enum Sex s = SECRET;
	Sex s2 = MALE;//typedef初始化后可以这样写

	printf("%d\n", sizeof(s2));//4 只能测其中某个常量的⼤⼩

	//printf("%d\n", MALE);
	//printf("%d\n", FEMALE);
	//printf("%d\n", SECRET);

	return 0;
}

3.2 枚举的优点

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

3.3 枚举的使用

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

4.联合体(共用体)

4.1 联合类型的定义

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

#include<stdio.h>

union Un
{
	char c;//1
	int i;//4
};

int main()
{
	union Un u = { 0 };
	u.c = 'w';
	u.i = 0x11223344;//u.c被覆盖了

	//printf("%d\n", sizeof(u));//4
	//三个地址相同
	//printf("%p\n", &u);//02E2F8A0
	//printf("%p\n", &(u.c));//02E2F8A0
	//printf("%p\n", &(u.i));//02E2F8A0

	return 0;
}

4.2 联合的特点

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

使用场景:多种选择只选择⼀个
例如:学校⽤户系统
⽤户：
学⽣（名字，年龄，身份）
⽼师（名字，年龄，职称）

Union type
{
	身份
	职称
};
UserInfo
{
	char name[20];
	int age;
	union type t;
}

之前练过的面试题:判断当前计算机的大小端存储

#include<stdio.h>

int cheak_sys()
{
	int a = 1;
	if (*(char*)&a == 1)//&a本来是int*的
	{
		return 1;//⼩端
	}
	else
	{
		return 0;//⼤端
	}
}
int cheak_sys()
{
	int a = 1;
	return (*(char*)&a);
}
int cheak_sys()
{
	union Un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int cheak_sys()
{
	//只⽤⼀次->不完全结构体声明
	union
	{
		char c;
		int i;
	}u;
	u.i = 1;//赋值
	return u.c;
}

int main()
{
	int ret = cheak_sys();
	if (1 == ret)
		printf("⼩端\n");
	else
		printf("⼤端\n");

	//如果返回1，表示⼩端
	//如果返回0，表示⼤端
	return 0;
}

4.3 联合体大小的计算

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

举个例子:

union Un1
{
	char c[5];//5个字节 1,8 - 1
	int i; //4个字节 4,8 - 4
};

union Un2
{
	short c[7];//14个字节 2,8-2
	int i; //4个字节 4,8-4
};

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

	return 0;
}

---

好了,针对于自定义的数据类型相关知识,我也给大家介绍完了,希望大家能够理解!

喜欢的话请一件三连熬~

送给大家一个小程序

#include<stdio.h>

int main()
{
	int day = 0;
	for (day = 0; day <= Life; day++)
	{
		printf("study hard day day up!\n");
	}
		
	return 0;
}