联合体，枚举，typedef

偏执的太偏执、 2022-11-29 00:55 178阅读 0赞

一、研究结构体在内存空间占用空间的大小。（64位）  
char/int这些都是系统中基本数据类型，大小都是固定。  
char -> 占用1个字节  
int -> 占用4个字节  
结构体是一种自定义的数据类型，那么会占用多少个字节？

请回答出以下的结构体在内存中占用的字节数？  
例子1：  
struct data\{ -> 32  
char name\[24\];  
long age;  
\};

例子2：  
struct data\{ -> 32  
long age;  
char name\[24\];  
\};

例子3：  
struct data\{ -> 16 12 9 -> 16  
double a;  
char b;  
\}

例子4：  
struct data\{ -> 8 16 12 10 -> 10  
char a;  
short c;  
char b;  
short d;  
char e;  
char f;  
\};

例子5：  
struct data\{ -> 8 12 -> 8  
char a;  
char b;  
short c;  
short d;  
char e;  
char f;  
\};

例子6：  
struct data\{ -> 16 11 12 15 14 -> 14  
char a;  
short c;  
short d;  
char e;  
char f;  
char g;  
short h;  
char w;  
\};

例子7：  
struct data\{ -> 16 24 13 -> 24  
int a;  
double b;  
char c;  
\};

练习1： 请计算出以下结构体的大小。 -> 88 96 92 80 74 108 136 -> 96  
struct data\{  
int a;  
char b;  
int (\*px)\[5\]  
char A\[9\];  
short c;  
double e;  
float d;  
double \*p;  
int B\[3\];  
char (\*p)(int,char);  
char q;  
short w;  
char o;  
int t;  
\};

struct data\{ -> 80 88 86 92 72 -> 80  
char k;  
char d;  
int (\*p)(int);  
char B\[7\];  
int a;  
char w;  
int A\[3\];  
short e;  
float c;  
char q;  
int \*px;  
char (\*fun)(char,float);  
long age;  
\}

二、联合体。  
1、为什么会有联合体？  
为了解决结构体占用空间过大的情况。

2、联合体如何定义？  
结构体：  
struct data\{  
int a;  
double b;  
char c;  
\}; -> 该结构体在内存中占用的空间是24个。

联合体的关键词：union，只需要将struct修改为union即可。  
union data\{  
int a; -> 占用4个字节  
double b;-> 占用8个字节  
char c; -> 占用1个字节  
\}; -> 该联合体在内存中占用的空间是8个。

3、结论。  
1）联合体只能在同一个瞬间使用其中的一个成员。

/\* 正确  
union data k;  
k.a = 10;  
strcpy(k.A,"hello");  
\*/  
  
//错误  
union data k = \{10,"hello"\};

2）联合体大小以联合体最大的那个成员说了算。（看看要不要补0）

union data\{  
int a; //4  
char A\[9\]; //9  
\};  
最大的那个是9个字节，因为在这个联合体中最长单位是4个字节，所以结果必须是4的倍数，里9最近的4个倍数就是12，后面需要补3个0

union data\{  
int a; -> 占用4个字节  
double b;-> 占用8个字节  
char c; -> 占用1个字节  
\};  
最大的那个是8个字节，因为在这个联合体中最长单位是8个字节，所以结果必须是8的倍数，因为8已经是8的倍数，所以8就是结果，不需要补0。

3）所有成员的起始地址都是一致的。  
4）联合体与结构体的变量都是可以作为函数的参数的。  
因为结构体太大了，所以很少会传递结构体变量过去，一般都是传递结构体指针。

\#include <stdio.h>  
\#include <string.h>

union data\{  
int a; //4  
char A\[9\]; //9  
\};

int fun(union data \*x) // x = a //8  
\{  
printf("x->a = %d\\n",x->a);  
return 0;  
\}

int main(int argc,char \*argv\[\])  
\{  
//printf("%ld\\n",sizeof(union data));  
union data x;  
x.a = 10;  
fun(&x);  
return 0;  
\}

4、当出现结构体嵌套的情况，该如何访问成员。  
假设：  
struct time\_value\{  
float play\_time; //人玩的时间  
float study\_time; //人学习的时间  
\};

struct person\_state\{  
char name\[20\]; //人的姓名  
int age; //人的年龄  
struct time\_value t; //人的时间  
\};

现有以下代码：  
struct person\_state ggy;  
struct person\_state \*p = &ggy;

请使用p对成员play\_time赋值，该如何赋值？  
p->t.play\_time = 5.0;

三、枚举类型。  
1、什么是枚举类型？  
其实枚举类型就是一些整型变量，意义就是给常量一个身份。  
例子：  
1 -> ok  
0 -> warning  
\-1 -> error

2、枚举类型一般作用于那些场景？  
1）作用于switch语句。  
2）函数返回值。

int fun()  
\{  
if(xxxx)  
....;  
return 0;  
else if  
....;  
return 1;  
else  
....;  
return -1;  
\}

修改成：  
int fun()  
\{  
if(xxxx)  
....;  
return warning; -> 好处： 别人看起来就知道返回值是什么情况。  
else if  
....;  
return ok;  
else  
....;  
return error;  
\}

3、如何定义枚举类型？  
关键词：enum  
模型：  
enum my\_data\{  
ok = 1,  
warning = 0,  
error = -1,  
\};

等价于  
int ok = 1,warning = 0,error = -1。

例子1：  
enum my\_data\{  
ok, //如果没有赋值，第一个成员从0开始 //0  
warning, //后面没有赋值的成员都会在前一个成员的基础上+1 //1  
error, //2  
\};

例子2：  
enum my\_data\{  
ok = 10,  
warning = 20,  
error, //21  
\};

例子3：  
enum my\_data\{  
ok = 10,  
warning = 9,  
error, //10  
\};

4、举例子。  
\#include <stdio.h>  
enum my\_data\{  
ok = 10,  
warning = 9,  
error,  
\};

int fun(int age)  
\{  
if(age < 18)  
return ok;  
else if(age == 18)  
return warning;  
else  
return error;  
\}

int main(int argc,char \*argv\[\])  
\{  
printf("ok = %d\\n",ok);  
printf("warning = %d\\n",warning);  
printf("error = %d\\n",error);  
  
int age = 18;  
int ret;  
ret = fun(age);  
printf("ret = %d\\n",ret);  
return 0;  
\}

四、typedef关键词。  
1、什么是typedef？作用是什么？  
typedef其实就是type + define,就是给一种数据类型(基本数据类型/非基本数据类型)取一个别名。  
例如：  
给int这种类型取一个新的别名叫aaa -> 很少给基本数据类型取新名 -> 1%  
给struct person\_state/int(\*)(int,int)取一个新的名字bbb -> 大部分时间都是给复杂类型取别名 -> 99%  
结构体类型 函数指针类型

typedef作用： 就是为了简化复杂的数据类型。

2、如何使用typedef给数据类型取别名？

例子1： 给int这种类型取一个新的别名叫aaa。  
1）在代码中定义一个int类型的变量，变量名就是你新的别名。 int aaa -> 变量aaa就是整型变量的变量名。  
2）在这个定义的语句的前面加typedef typedef int aaa -> aaa就是int这种类型的新别名。  
3）在后面的代码中定义整型变量 aaa a -> 前面的aaa： 数据类型  
后面的a： 变量名

例子2： 给struct person\_state取一个新的别名叫person\_state。

struct person\_state\{  
char name\[10\];  
int age;  
\};

1）在代码中定义一个struct person\_state类型的变量，变量名就是你新的别名。  
struct person\_state person\_state -> 变量person\_state就是结构体类型struct person\_state的变量名。

2）在这个定义的语句的前面加typedef。  
typedef struct person\_state person\_state -> person\_state就是struct person\_state新的别名。

3）在后面的代码中定义结构体变量。  
本来： struct person\_state ggy;  
现在： person\_state ggy; -> 前面person\_state是数据类型， ggy就是变量名。

3、已知typedef取别名的代码，求出是谁替代谁？  
例子1： 已知typedef int aaa，请问是谁替代谁？

1）先将typedef去掉 int aaa  
2）剩余的语句中肯定有"数据类型 + 变量名" 数据类型： int 变量名： aaa  
3）结果就是该变量名替代了数据类型 aaa替代了int

例子2： 已知 typedef void (\*sighandler\_t)(int); 请问是谁替代谁？

1）先将typedef去掉 void (\*sighandler\_t)(int)  
2）剩余的语句中肯定有"数据类型 + 变量名" 数据类型： void (\*)(int) 变量名：sighandler\_t  
3）结果就是该变量名替代了数据类型 sighandler\_t替代了void (\*)(int)

假设有一个函数： void fun(int a);  
以前： void (\*p)(int) = &fun;  
现在： sighandler\_t p = &fun;

记住： 不能够这样写  
typedef int aaa -> 正确的  
typedef void (\*)(int) sighandler\_t -> 错误的  
typedef void (\*sighandler\_t)(int) -> 正确的

3、typedef大多数都是作用结构体的比较多。  
按照刚才的写法：  
struct person\_state\{  
char name\[20\];  
int age;  
\};

typedef struct person\_state person\_state -> struct person\_state 等价于 person\_state  
typedef struct person\_state\* person\_state\_point -> struct person\_state\* 等价于 person\_state\_point

person\_state ggy;  
person\_state\_point p = &ggy;

一般在代码中，看到的是这样的：  
typedef struct data\{  
char name\[20\];  
int age;  
\}data,\*pdata;

struct data -> 结构体类型  
等价于  
data -> 结构体类型

struct data \* -> 结构体指针类型  
等价于  
pdata -> 结构体指针类型