结构体类型详细讲解（附带枚举，联合）

前言：

如果你还对结构体不是很了解，那么本篇文章将会从 为什么存在结构体，结构体的优点，结构体的定义，结构体的使用与结构体的大小依次介绍，同样会附带枚举与联合体

目录

 为什么存在结构体：

 结构体的优点

结构体的定义 

结构体的使用

结构体的typedef 

 结构体的大小计算

 枚举

 枚举的使用案例

联合体（也叫共用体）

---

 为什么存在结构体：

当一个整体由多个数据构成时，于是人们就创造了数组，我们用数组来表示这个整体，但是数组有个特点：内部的每一个元素都必须是相同类型的数据。 ☀ 在实际应用中，我们通常需要由不同类型的数据来构成一个整体，比如学生这个整体可以由姓名、年龄、身高等数据构成，这些数据都具有不同的类型，姓名可以是字符串类型，年龄可以是整型，身高可以是浮点型。 ☀ 为此，C语言专门提供了一种构造类型来解决上述问题，这就是结构体，它允许内部的元素是不同类型的。

 结构体的优点

• 可以在一个结构中声明不同的数据类型。
• 相同结构的结构体变量是可以相互赋值的。
• 结构体的存储方式可以提高CPU对内存的访问速度。
• 结构体可以将同一对象的多个数据类型存储在一起，方便数据的存储和处理。
• 可以通过结构体变量名和成员名来访问数据。
• 可以定义结构体数组，方便批量处理数据。

那么有有优点就会有缺点：

• 如果项目的复杂性增加，管理所有数据成员就变得很困难 。
• 对程序中的一个数据结构进行更改需要在其他几个地方进行更改。 所以很难跟踪所有的变化。
• 结构体需要更多的存储空间，因为它为所有数据成员分配内存，甚至速度更慢。
• 结构体占用更多存储空间，因为它为所有不同的数据成员提供内存，而联合仅占用最大数据大小参数所需的内存大小，并且与其他数据成员共享相同的内存。

结构体的定义 

 一般结构体定义便是如下

struct stu
{
	//变量成员
};

这里的struct是必不可少的部分，而stu是我们自拟定的，里面便是填充的变量成员

这个结构体就是struct stu类型的

同理下面这个结构体就是struct st类型的

struct st
{
	//变量成员
};

 这时候我们便可以在里面填充成员

比如这样

struct st
{
	int a;
    char b;
    struct st* ps;//也可以填充这个类型的指针
};

那么结构体定义完后，我们开始讲解怎么去使用

结构体的使用

这里的s为变量名 

struct st
{
    int a;
    char b; 
};
int main()
{
    struct st s = { 10,'b' };//初始化
    return 0;
}

 接下来介绍打印

方法一：

struct st
{
    int a;
    char b; 
};
int main()
{
    struct st s = { 10,'b' };//初始化
    printf("%d %c", s.a, s.b);
    return 0;
}

 

方法二   函数传值打印

struct st
{
    int a;
    char b; 
};
void print(struct st ps)
{
    printf("%d %c", ps.a, ps.b);
}
int main()
{
    struct st s = { 10,'b' };//初始化
    print(s);
    return 0;
}

 

方法三  函数传址打印   两种打印方法

第一种的打印是利用解引用

第二种是利用->  这里的 ->就相当于(*).

struct st
{
    int a;
    char b; 
};
void print(struct st* ps)
{
    printf("%d %c\n", (*ps).a, (*ps).b);
    printf("%d %c\n", ps->a, ps->b);
}
int main()
{
    struct st s = { 10,'b' };//初始化
    print(&s);
    return 0;
}

方法四  跟方法三差不多，不利用函数打印 

struct st
{
    int a;
    char b; 
};
int main()
{
    struct st s = { 10,'b' };//初始化
    struct st* ps = &s;
    printf("%d %c\n", (*ps).a, (*ps).b);
    printf("%d %c\n", ps->a, ps->b);
    return 0;
}

结构体的typedef 

 当一个结构体类型的类型名过于长的时候，我们不免过于不想去写，这时候就可以用typedef

（重命名）使用起来很简单

typedef struct st
{
    int a;
    char b; 
}st;
int main()
{
    struct st s = { 10,'b' };//初始化
    //等价于
    st s = { 10,'b' };//
    return 0;
}

 结构体的大小计算

先举例一个代码

代码跑出来这个结构体大小是8 

那么怎么计算的呢？  其原理就是对其原则

 ⾸先得掌握结构体的对⻬规则：

1.结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处

 2.其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。对⻬数=编译器默认的⼀个对⻬数与该成员变量⼤⼩的较⼩值。VS 中默认的值为 8

Linux中gcc没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

3.结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的整数倍。

4.如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构 体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

我们计算一下这个结构体大小 

struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%d\n", sizeof(struct S1))

先解决对其数问题

char    自身对齐数为1  vs上默认对齐数为8    实际取小的   那么最后为1

int 为4 

 偏移量

在C语言中，偏移量通常指的是结构体中成员变量相对于结构体起始地址的偏移量。假设有一个结构体定义如下：

struct Person {
    int id;
    char name[20];
    int age;
};

假设struct Person p;是一个Person类型的结构体变量，我们可以通过&p.id、&p.name和&p.age来获取各个成员变量的地址。偏移量就是从结构体起始地址到成员变量地址的字节偏移量。

例如，假设&p表示结构体p的起始地址，&p.id表示id成员变量的地址，那么&p.id - &p就是id相对于结构体起始地址的偏移量。在C语言中，可以使用指针和强制类型转换来计算偏移量，例如：

int offset = (char *)&p.name - (char *)&p;

 这样就可以得到name成员变量相对于结构体p的偏移量。偏移量在一些底层编程中经常用来访问结构体中的特定成员变量，尤其是在处理二进制数据或者硬件寄存器时非常有用。

画图表示如下

 那么我们进行利用图进行计算

typedef struct st
{
    char c1;
    int i;
    char c2; 
}st;
int main()
{
    printf("%zd", sizeof(st));
    return 0;
}

第一个char偏移量为0放于第一个，int放于偏移量为4的整数倍数处  ，最后一个char偏移量为1，放于1的整数倍数处，

用图表示如下

图上的大小一共占了9个字节，

然后我们进行最后一步 最大对齐数为4  而9不是最大对齐数的整数倍   所以要浪费3个字节补充该结构体大小到12；

那么知道怎么算了就可以解答上面那个问题为什么是8

//练习3 
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));
//练习4-结构体嵌套问题 
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%d\n", sizeof(struct S4));

答案分别是16    32         

 然而我们上面的所有计算都是根据vs给定的默认偏移量为8来进行计算的，vs默认为8其实是采用了以空间换时间的方式进行设计的。我们也可以进行自定义偏移量，比如设定为1，这时候就是以时间换空间了；展示代码：

修改默认的对齐数：

#pragma pack(4)//设置默认对齐数为4  此时这个结构体大小为12
//#pragma pack()//中不写数字的话，表示取消之前的指定对齐数，改为默认的值
//默认对齐数为1的话下面大小就是9
struct s
{
	char a;
	double d;
};
int main()
{
	printf("%d", sizeof(s));
	return 0;
}

 另外还可以使用宏定义offsetof，计算结构体中某变量相对于首地址的偏移

//宏的使用  offsetof
//需要引用头文件  stddef.h
//作用查看该类型所在的偏移量
//第一个为类型名（不是变量名）
//第二个是成员名

#include<stddef.h>
struct s
{
	char a;
	int c;
	double d;
};
int main()
{
	printf("%d\n", offsetof(struct s, a));
	printf("%d\n", offsetof(struct s, c));
	printf("%d\n", offsetof(struct s, d));
	return 0;
}

 

那么在这里就直接给出宏offsetof的实现吧：

offsetof的实现：

代码解释就在截图上。

#define my_offsetof(type,member) (size_t)(&(((type*)0)->member))
//先将结构体地址手动置为0，此时member也会改变，然后将其指向member
//此时member的地址对应的就是偏移量
struct s
{
	char a;
	int c;
	double d;
};
int main()
{
	printf("%d\n", my_offsetof(struct s, a));
	printf("%d\n", offsetof(struct s, a));
	return 0;
}

运行效果： 

 枚举

 在《C语言深度剖析》这本书中留有一个问题，枚举变量的大小是多少？

大家猜一下大小为多少

enum Color
{
    GREEN = 1,
    RED,
    BLUE,
    GREEN_RED = 10,
    GREEN_BLUE,
    sss,
}c;
int main()
{
    printf("%zd", sizeof(c));
}

答案是4，为啥呢？

因为，枚举变量的取值为花括号内的任意类型的大小值（有且只能有其中一个），而这个枚举里面全是int类型的，int型的数据占内存4个字节。所以sizeof(c) = 4，也就是枚举变量的值为4。

 枚举的使用案例

当我们写菜单的时候，会用到switch语句

当我们写case是一般会用到case 1： case 2：

但如果功能一旦多我们就会分不清该case  要实现哪一项功能

这时候就可以用到枚举  就比如通讯录

enum option
{
	EXIT,//等价于0
	ADD,//1
	DEL,//2
	SEARCH,//3
	MODIFY,//4
	SHOW, //5
	SORT,//6
	SAVE,//7
};

void menu()
{
	printf("**************************************\n");
	printf("*****    1.add        2.del      *****\n");
	printf("*****    3.search     4.modify   *****\n");
	printf("*****    5.show       6sort      *****\n");
	printf("*****    7.save       0.exit     *****\n");
	printf("**************************************\n");
}
int main()
{
	do {
		menu();
		printf("请输入你的选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case ADD:
			Addcontact(&con);
			break;
		case DEL:
			Delcontact(&con);
			break;
		case SEARCH:
			Searchcontact(&con);
			break;
		case MODIFY:
			Modifycontact(&con);
			break;
		case SHOW:
			Showcontact(&con);
			break;
		case SORT:
			SortContact(&con);
			break;
		case SAVE:
			SaveContact(&con);
			break;
		case EXIT:
			SaveContact(&con);
			DestroyContact(&con);
			printf("退出通讯录\n");
			break;
		default:
			printf("输入错误，请重新输入:>\n");
			break;
		}

	} while (input);
	return 0;
}

联合体（也叫共用体）

 联合的成员是共⽤同⼀块内存空间的，这样⼀个联合变量的⼤⼩，⾄少是最⼤成员的⼤⼩（因为联合 ⾄少得有能⼒保存最⼤的那个成员）。

那么看以下代码

发现三者的空间是共用一块空间，所以这也对应了名字共用体，公用一块空间

#include <stdio.h>
union Un
{
 char c;
 int i;
};
int main()
{
 //联合变量的定义 
 union Un un = {0};
 un.i = 0x11223344;
 un.c = 0x55;
 printf("%x\n", un.i);
 return 0;
}

既然公用一块空间那么（小端）

这个代码运行结果如何呢？

我们发现将i的第4个字节的内容修改为55了（其实是改的低地址处的数据）

同样大端下会打印55223344； 

利用联合体写一个函数判断机器为大端还是小端

int check_sys()
{
 union
 {
 int i;
 char c;
 }un;
 un.i = 1;
 return un.c;//返回1是⼩端，返回0是⼤端 
}