自定义类型详解（结构体，枚举，联合）

最新推荐文章于 2024-05-21 21:11:24 发布

冷色调的火

最新推荐文章于 2024-05-21 21:11:24 发布

阅读量346

点赞数

文章标签： c语言

本文链接：https://blog.csdn.net/m0_69460362/article/details/127111772

版权

5.1练习：实现一个通讯录（1.静态版本）

结构体

1.结构体的声明

1.1结构的基础知识

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

1.2结构体的声明

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//结构体类型的定义
//学生
//仅仅是创建了一个类似int,float的类型
//不需要初始化
struct Stu
{
	//学生的相关属性
	char name[20];
	int age;
}s1,s2;//s1，s2是全局变量
//这里的s1，s2是利用上面的类型创建的变量
//s1,s2的类型是struct Stu
//如果s1和s2放在主函数外面，s1和s2就是全局变量
//如果s1和s2放在主函数内部，s1和s2就是局部变量
int main()
{
	//不仅可以直接在结构体后创建变量，也可以在主函数内部创建变量
	struct Stu s3;//s3是局部变量
	return 0;
}

1.3.特殊的声明

在声明结构的时候，可以不完全的声明

//匿名结构体类型
//只能使用一次
struct
{
	//学生的相关属性
	char name[20];
    int age;
}s1;

//即使用匿名结构体类型定义了一个指针，也不能把同类型的变量地址赋值给这个指针
struct
{
	char name[20];
	int age;
}x;
struct
{
	char name[20];
	int age;
}*p;
int main()
{
	p = &x;
	return 0;
}

//结构体会把上面的两个声明当做完全不同的两个类型

2.结构体的自引用

在结构体中包含一个类型为该结构本身的成员

类似于链表在成员1的结构里存放2的地址，以此方式找到1，2，3，4，5，找到5后，在最后一个成员的结构里指向空指针结束查询

这里就用到了结构的自引用，这个结构里包含1和2的地址，通过2的地址找到2，然后2的结构里又包含2和3的地址……，最后找到5，并且指向一个空指针结束自引用

错误版本：

struct Node
{
	int i;
	//包含一个整型成员
	struct Node next;
	//自引用找下一个结点
};
//但是有一个严重的错误，这个结构的自引用什么时候到头，也就是说无法计算这个结构的大小
int main()
{
	sizeof(struct Node);
	return 0;
}

正确写法

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

错误写法

//不要把匿名结构体类型和自引用一起使用，否则程序运行会报错
typedef struct
{
	int i;
	struct Node* next;
}Node;

正确写法

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

之后使用结构体时，

struct Node n1;

相当于

Node n2;

也就是使用typedef重命名结构体类型为Node

结构体指针的写法

写法1

typedef struct Node
{
	int num;
	struct Node* next;
}* linklist;

把

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

重定义为

linklist

写法2

struct Node
{
	int num;
	struct Node* next;
};
typedef struct Node* linklist;

写法一直接把定义结构体类型和重命名结合到一起写，法2分步进行

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

在定义结构体类型的同时定义结构体变量

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

定义结构体类型后，定义结构体变量

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

初始化

struct Point
{
    int x;
    int y;
}p1 = {2,3};

结构体包含结构体的初始化

struct Point
{
    int i;
    char name[20];
    struct score s1;
};

struct score
{
    int x;
    char name[20];
};

int main()
{
    struct Point p1 = {1,"zhangsan",{2,"lisi"}};
    printf("%d,%s,%d,%s",p1.i,p1.name,p1.s1.x,p1.s1.name);

    return 0;
}

4.结构体内存对齐

尽管结构体的成员一样，但是存放顺序不同，结构体大小就不同，为什么？由此引出结构体内存对齐的知识

struct S1
{
	char i;
	int j;
	char k;
};
struct S2
{
	char x;
	char y;
	int z;
};
int main()
{
	printf("%d\n",sizeof(struct S1));
	printf("%d\n",sizeof(struct S2));

	return 0;
}

4.1结构体对齐规则

1.第一个成员在与结构体变量偏移量为0的地址

2.其他成员变量要对其到某个数字（对齐数）的整数倍的地址处

对齐数 = 编译器默认的一个对齐数与该成员大小的较小值

vs中默认的值为8

3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍

4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数的（含嵌套结构体的对齐数）整数倍

#include<stddef.h>
struct test
{
	char num1;
	char num2;
	int x;
};
struct test2
{
	char num3;
	int y;
	char num4;
};
struct test3
{
	char num5;
	struct test2;
	char i;
};
int main()
{
	printf("%d\n",offsetof(struct test,num1));
	printf("%d\n",offsetof(struct test,num2));
	printf("%d\n",offsetof(struct test,x));
	printf("%d\n",offsetof(struct test2, num3));
	printf("%d\n",offsetof(struct test2,num4));
	printf("%d\n",offsetof(struct test2,y));
	printf("%d\n",offsetof(struct test3,num5));
	printf("%d\n",offsetof(struct test3,i));
	//offsetof返回结构体成员在这个类型创建中的偏移量，需要引用头文件#include<stddef.h>

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

	return 0;
}

从结果可以看出 4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数的（含嵌套结构体的对齐数）整数倍

4.2为什么结构体要内存对齐

1.平台原因

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

2.性能原因

数据结构（尤其是栈）应该尽可能地在自然边界上对齐

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问

如果有了对齐规则，只需一次访问就能完全获取i的数据

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

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

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

4.3默认对齐数的修改

默认对齐数的修改

用#pragma这个预处理指令可以修改默认对齐数

#include<stdio.h>
#pragma pack(1)
//设置默认对齐数为1
struct S1
{
	char x;
	char y;
	int q;
};
#pragma pack()
//取消设置的默认对齐数，还原为默认
//通常以恢复默认作为结束
int main()
{
	printf("%d\n",sizeof(struct S1));
	return 0;
}

输出结果

#progam once 通常放在头文件位置，防止头文件被多次引用

5.结构体传参

struct S
{
	int data[1000];
	int num;
};
void print1(struct S ss)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d\n",ss.data[i]);
	}
	printf("%d\n",ss.num);
}

void print2(const struct S* ps)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d\n",ps->data[i]);
	}
	printf("%d\n",ps->num);
}
int main()
{
	struct S s = { { 1,2,3 },100 };
	print1(s);//传值调用
	print2(&s);//传址调用，比传值调用占用的空间更小，速度更快

	return 0;
}

一般首选函数print2的传址调用

原因：

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销

如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降

结论：

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

5.1练习：实现一个通讯录（1.静态版本）

建立一个通讯录要有一下功能：

1.存放100个人的信息

（认得信息：名字，年龄，性别，电话，地址）

2.增加联系人

3.删除指定联系人

4.查找联系人

5.修改联系人

6.排序

7.显示联系人

封装为三个模块

test.c 测试功能

contact.c 通讯录相关的实现

contact.h 通讯录相关的声明

test.c（测试功能）

#define _CRT_SECURE_NO_WARNINGS
#include "contact.h"

//使用枚举增加了代码的可读性
enum Option
{
    EXIT,
    ADD,
    DEL,
    SEARCH,
    MODIFY,
    SHOW,
    SORT,
};

void menu()
{
	printf("*********************************************************\n");
	printf("*************   1.add             2.del   ***************\n");
	printf("*************   3.search          4.modify **************\n");
	printf("*************   5.show            6.sort  ***************\n");
	printf("*************   0.exit                    ***************\n");
	printf("*********************************************************\n");
}
int main()
{
	int input = 0;
	Contact con;//创建了通讯录变量
	//初始化通讯录
	InitContact(&con);
	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 EXIT:
			printf("退出通讯录\n");
			break;
		default:
			printf("输入错误\n");
			break;
		}
	} while (input);

	return 0;
}

contact.c （通讯录相关的实现）

#define _CRT_SECURE_NO_WARNINGS
#include "contact.h"

void InitContact(Contact* pc)
{
	assert(pc);
	pc->count = 0;
	memset(pc->data,0,sizeof(pc->data));
}

void AddContact(Contact* pc)
{
	assert(pc);
	if (pc->count == MAX)
	{
		printf("通讯录已满，无法添加\n");
		return;
	}
	printf("请输入名字：");
	scanf("%s", pc->data[pc->count].name);
	printf("请输入年龄：");
	scanf("%d",&(pc->data[pc->count].age));
	printf("请输入性别：");
	scanf("%s",pc->data[pc->count].sex);
	printf("请输入电话：");
	scanf("%s",pc->data[pc->count].tele);
	printf("请输入地址：");
	scanf("%s",pc->data[pc->count].addr);

	pc->count++;
	printf("增加成功\n");
}

void ShowContact(const Contact* pc)
{
	assert(pc);
	printf("%20s\t%5s\t%5s\t%12s\t%30s\n","名字","年龄","性别","电话","地址");
	//一个汉字是两个字节，所以这里的年龄项用了%5s，为了保持对齐，下面也用了%5d
	//想要左对齐在百分号后面加负号
	int i = 0;
	for (i = 0; i < pc->count; i++)
	{
		printf("%20s\t%5d\t%5s\t%12s\t%30s\n",  pc->data[i].name,
												pc->data[i].age,
												pc->data[i].sex,
												pc->data[i].tele,
												pc->data[i].addr);
	}
}

//添加了static的代码只能在.c源文件看到
static int FindByName(Contact* pc, char name[])
{
	assert(pc);
	int i = 0;
	for (i = 0; i < pc->count; i++)
	{
		if (0 == strcmp(pc->data[i].name, name))
		{
			return i;
		}
	}
	return -1;
}

void DelContact(Contact* pc)
{
	char name[MAX_NAME] = { 0 };
	assert(pc);
	int i = 0;
	if (pc->count == 0)
	{
		printf("通讯录为空，没有信息可以删除\n");
		return;
	}
	printf("请输入要删除人的名字:>");
	scanf("%s",name);
	//删除
	//1.查找
	int pos = FindByName(pc,name);
	if(pos == -1)
	{
		printf("要找的人不存在\n");
		return;
	}
	//2.删除
	for (i = pos; i < pc->count-1; i++)
	{
		pc->data[i] = pc->data[i+1];
		//拿后面的元素依次覆盖前面的元素
	}
	pc->count--;
	//覆盖后，也就相当于删除了一个人的信息
	//如果要删除最后一个人的信息，直接count--，因为访问函数是通过count的值来完成访问的
	//count--之后的count作了最大值，也就无法访问count--之前的count的值，从而达到删除最后一个的信息的目的
	//要结合前面的ShowContact函数理解
	printf("删除成功\n");
}

void SearchContact(Contact* pc)
{
	assert(pc);
	char name[MAX_NAME] = { 0 };
	printf("请输入要查找的人的名字：>");
	scanf("%s", name);
	//查找
	int pos = FindByName(pc,name);
	if (pos == -1)
	{
		printf("要查找的人不存在\n");
		return;
	}
	//打印
	else
	{
		printf("%20s\t%5s\t%5s\t%12s\t%30s\n", "名字", "年龄", "性别", "电话", "地址");
		//一个汉字是两个字节，所以这里的年龄项用了%5s，为了保持对齐，下面也用了%5d
		//想要左对齐在百分号后面加负号
		printf("%20s\t%5d\t%5s\t%12s\t%30s\n", pc->data[pos].name,
												pc->data[pos].age,
												pc->data[pos].sex,
												pc->data[pos].tele,
												pc->data[pos].addr);
	}
}

void ModifyContact(Contact* pc)
{
	assert(pc);
	char name[MAX_NAME] = { 0 };
	printf("请输入要修改的人的名字：>");
	scanf("%s",name);
	//1.查找
	int pos = FindByName(pc,name);
	if (pos == -1)
	{
		printf("要修改的人不存在\n");
		return;
	}
	//2.修改
	else
	{
		printf("要修改的人已找到，请修改信息\n");
		printf("请输入名字：");
		scanf("%s", pc->data[pos].name);
		printf("请输入年龄：");
		scanf("%d", &(pc->data[pos].age));
		printf("请输入性别：");
		scanf("%s", pc->data[pos].sex);
		printf("请输入电话：");
		scanf("%s", pc->data[pos].tele);
		printf("请输入地址：");
		scanf("%s", pc->data[pos].addr);

		printf("修改成功\n");
	}

}

static int cmp_peo_by_name(const void* e1, const void* e2)
{
	return strcmp(((PeoInfo*)e1)->name,((PeoInfo*)e2)->name);
}
//按照名字来排序
void SortContact(Contact* pc)
{
	assert(pc);
	//起始位置，比较的成员个数，每个成员的大小
	qsort(pc->data,pc->count,sizeof(PeoInfo),cmp_peo_by_name);
	printf("排序成功\n");
}

contact.h （通讯录相关的声明）

#pragma once

#include<string.h>
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

#define MAX 100
#define MAX_NAME 20
#define MAX_SEX 10
#define MAX_TELE 12
#define MAX_ADDR 30
//类型的声明

//人的信息
typedef struct PeoInfo
{
	char name[MAX_NAME];
	int age;
	char sex[MAX_SEX];
	char tele[MAX_TELE];
	char addr[MAX_ADDR];
}PeoInfo;
//加了typedef重命名类型struct PeoInfo

//通讯录
typedef struct Contact
{
	PeoInfo data[MAX];//存放人的信息
	int count;//记录当前通讯录中实际人的个数
}Contact;

//对初始化通讯录的函数的声明
void InitContact(Contact *pc);
//传的是Contact类型的地址，所以声明的就是Contact类型的指针

//对增加联系人的通讯录的函数的声明
void AddContact(Contact* pc);

//对打印通讯录中的信息的函数的声明
void ShowContact(const Contact* pc);

//对删除通讯录中的信息的函数的声明
void DelContact(Contact* pc);

//对查找指定联系人的函数进行声明
void SearchContact(Contact *pc);

//对修改指定联系人信息的函数进行声明
void ModifyContact(Contact *pc);

//对排序通讯录中的内容的函数进行声明
//按照名字来排序
//按照年龄来排序
//……
void SortContact(Contact *pc);

以上就是通讯录功能的简单实现

6.位段

6.1什么是位段

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

1.位段的成员必须是int ， unsigned int ,或，signed int

2.位段的成员名后边有一个冒号和一个数字

比如：

struct A
{
	int _a : 2;   //占2个比特位
	int _b : 5;   //占5个比特位
	int _c : 10;  //占10个比特位
	int _d : 30;  //占30个比特位
};

A就是一个位段类型。

位段是用来节省空间的

那位段A的大小是多少？

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};

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

6.2位段的内存分配

1.位段的成员可以是int ，unsigned int ，signed int 或者是char(属于整型家族)类型

2.位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的

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

可见位段节省空间并不是绝对的，也存在内存浪费的现象，但总体上是节省了空间

6.3位段的跨平台问题

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

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

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

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

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

6.4位段的应用

枚举

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

把可能的取值一一列举

1.枚举类型的定义

//星期
enum Day
{
    Mon,
    Tues,
    Wed,
    Thur,
    Fri,
    Sat,
    Sun
};

//三原色
enum Color
{
    Red;
    Green;
    Bule;
};

//性别
enum Sex
{
    Male;
    Fmale;
    Secret;
};

若果不给Mon赋初值，打印结果如下

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

	return 0;
}

如果给Mon赋初值，结果如下

#include<stdio.h>
enum Day
{
	Mon = 1,
	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);

	return 0;
}

2.枚举的优点

为什么使用枚举

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

枚举的优点：

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

比如通讯录代码我们利用1,2,3……这些数字控制功能，不易于阅读，比如为什么1控制了增加联系人的功能，为什么不是直接通过ADD来控制添加联系人的功能，这里利用枚举可以优化

优化前

#define _CRT_SECURE_NO_WARNINGS
#include "contact.h"

void menu()
{
	printf("*********************************************************\n");
	printf("*************   1.add             2.del   ***************\n");
	printf("*************   3.search          4.modify **************\n");
	printf("*************   5.show            6.sort  ***************\n");
	printf("*************   0.exit                    ***************\n");
	printf("*********************************************************\n");
}
int main()
{
	int input = 0;
	Contact con;//创建了通讯录变量
	//初始化通讯录
	InitContact(&con);
	do
	{
		menu();
		printf("请选择：");
		scanf("%d",&input);
		switch (input)
		{
		case 1:
			AddContact(&con);
			break;
		case 2:
			DelContact(&con);
			break;
		case 3:
			SearchContact(&con);
			break;
		case 4:
			ModifyContact(&con);
			break;
		case 5:
			ShowContact(&con);
			break;
		case 6:
			SortContact(&con);
			break;
		case 0:
			printf("退出通讯录\n");
			break;
		default:
			printf("输入错误\n");
			break;
		}
	} while (input);

	return 0;
}

优化后：

#define _CRT_SECURE_NO_WARNINGS
#include "contact.h"

enum Option
{
	EXIT,
	ADD,
	DEL,
	SEARCH,
	MODIFY,
	SHOW,
	SORT,
};

void menu()
{
	printf("*********************************************************\n");
	printf("*************   1.add             2.del   ***************\n");
	printf("*************   3.search          4.modify **************\n");
	printf("*************   5.show            6.sort  ***************\n");
	printf("*************   0.exit                    ***************\n");
	printf("*********************************************************\n");
}
int main()
{
	int input = 0;
	Contact con;//创建了通讯录变量
	//初始化通讯录
	InitContact(&con);
	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 EXIT:
			printf("退出通讯录\n");
			break;
		default:
			printf("输入错误\n");
			break;
		}
	} while (input);

	return 0;
}

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

错误：

#include<stdio.h>
enum Day
{
	Mon = 1,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
int main()
{
	enum Day a = 10;
//10是int型数据，不是enum Day类型的数据，数据类型不一样，在C语言语法可能检测不出来，但是在C++语法下会报错

	return 0;
}

正确：

#include<stdio.h>
enum Day
{
	Mon = 1,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
int main()
{
	enum Day a = Fri;

	return 0;
}

C语言对语法检查可能不太严格，如果用C++检查语法就会出错，所以使用枚举可以使代码更加严谨

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

也就是说把枚举成员都放在了枚举类型的大括号里，就像封装起来了一样


enum Day
{
	Mon = 1,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};

4.便于调试

代码在执行时会经过

test.c------------------>（预处理）------------------>编译------------------->链接------------>.exe文件

#define定义的常量在预处理的时候会将这个代码里的M换成100，在调试时就无法观察到这个M

而通过枚举定义的Fri不会变换

#define M 100
int main()
{
	enum Day a = Fri;
	int m = M;

	return 0;
}

所以说使用枚举比使用#define定义的字符更加便于观察

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

和#define相比较，枚举可以一次定义多个变量，使用方便

3.枚举的使用

正确：

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

错误：

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

只能拿枚举常量给枚举变量赋值，才不会出现类型的差异

联合（共用体）

1.联合类型的定义

联合也是一种特殊的自定义类型

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

比如：

#include<stdio.h>

union Un
{
	int a;
	char c;
};

//共用
int main()
{
	union Un u;
	printf("%d\n",sizeof(u));

	printf("%p\n",&u);
	printf("%p\n", &(u.a));
	printf("%p\n", &(u.c));

	return 0;
}

可见联合体（共用体）变量和联合体（共用体）的各个成员在内存中占了同一片内存空间

共用体所占内存空间的大小由占内存空间最大的共用体成员决定

类似于共享单车，a用了，c不能用，等a用完了，c再用

2.联合的特点

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

union Un
{
	int a;
	char c;
};

那么这个联合体的大小至少是四个字节，因为至少得把a存储下来

当其中后面某个成员的首地址改变，位于它前面的其他成员的首地址也改变

#include <stdio.h>

union Un
{
	int a;
	char c;
};

//共用
int main()
{
	union Un u;
	printf("%d\n",sizeof(u));

	printf("%p\n",&u);
	printf("%p\n", &(u.a));
	printf("%p\n", &(u.c));

	u.a = 0x11223344;
	u.c = 0x00;

	return 0;
}

当c的首地址改变，a的首地址也发生改变

也能看出数据再内存中的存储是小端存储

例题：判断计算机的大小端存储

普通：

int check_sys()
{
	int a = 1;
	return *(char*)&a;
	//只需要看第一个字节的数据就可以，只有char*指针解引用才能得到一个字节的数据
	//返回值是1就是小端（后往前）
	//返回值是0就是大端（前往后）

};
int main()
{
	//int a = 1;
	//1在内存的二进制序列是00 00 00 01
	//假设数据再内存中存储数据是按小端存储
	// 低 ----------> 高的顺序存储的，那么会在查看时显示01 00 00 00
	//如果按大端存储
	// 高 ----------> 低，那么会显示00 00 00 01
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}

利用联合体特性判断：

int check_sys()
{
	//只需要看第一个字节的数据就可以，只有char*指针解引用才能得到一个字节的数据
	//返回值是1就是小端（后往前）
	//返回值是0就是大端（前往后）
	union Un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	//int a = 1;
	//1在内存的二进制序列是00 00 00 01
	//假设数据再内存中存储数据是按小端存储
	// 低 ----------> 高的顺序存储的，那么会在查看时显示01 00 00 00
	//如果按大端存储
	// 高 ----------> 低，那么会显示00 00 00 01
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}

如果要优化的话，可以改函数内的联合体为匿名联合体，因为这个函数内的联合体只使用了一次，且在其他地方不使用

int check_sys()
{
	//只需要看第一个字节的数据就可以，只有char*指针解引用才能得到一个字节的数据
	//返回值是1就是小端（后往前）
	//返回值是0就是大端（前往后）

    //改为匿名联合体，定义匿名联合体名为u
	union 
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}

3.联合大小的计算

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

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

union Un1
{
	char arr[5];//成员大小是5，对齐数是1
	int i;//成员大小是4，对齐数是4
};
//这里的数组虽然有五个成员但仍然以char为成员大小
//所以这个联合体成员最大为4字节的int型
//虽然联合体的最大成员大小是5，但是联合体的最大对齐数是4，所以联合体要对齐到最大对齐数，即联合体大小为8
int main()
{
	printf("%d\n",sizeof(union Un1));
	return 0;
}

类似的有

union Un1
{
	short arr[7];//成员大小是14，对齐数是2
	int i;//成员大小是4，对齐数是4
};
//所以最大成员数是14，最大对齐数是4
//14不是4的倍数
//取4的倍数即16

int main()
{
	printf("%d\n",sizeof(union Un1));
	return 0;
}

结语

能看到这里很了不起啊，晚饭记得给自己加根鸡腿

好啦，以上就是自定义类型详解的全部内容了

如果有帮助到你的话不要忘记一键三连

这里是cool fire，人海茫茫，相遇不易，我们下次再见

冷色调的火

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
自定义类型详解（结构体，枚举，联合）

在定义结构体类型的同时定义结构体变量{int x;int y;}p1;定义结构体类型后，定义结构体变量{int x;int y;};初始化{int x;int y;结构体包含结构体的初始化{int i;};{int x;};}位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int ， unsigned int ,或，signed int2.位段的成员名后边有一个冒号和一个数字struct A{
复制链接

扫一扫