您现在的位置是：首页 > 其它

当前栏目

C结构、联合、枚举

结构联合枚举

2023-06-13 09:15:37 时间

结构

使用struct关键词，可以创造新的类型。关键词struct取自structure，中文翻译为结构。这种由多个不同的数据类型组成的类型，被称为结构。

struct {
	char name[20];
	int gender;
	double height;
	double weight;
}

上面这一串结构类型虽然很长，但是，就相当于 int 类型一样。如同在 int 后填变量名可以声明一个整型变量。在结构类型后面填写变量名可以声明一个结构变量。

结构别名

现在，我们想定义多个人员信息结构变量。

struct {
	char name[20];
	int gender;
	double height;
	double weight;
}timmy;
struct {
	char name[20];
	int gender;
	double height;
	double weight;
}david;
struct {
	char name[20];
	int gender;
	double height;
	double weight;
}jane;

struct person {
	char name[20];
	int gender;
	double height;
	double weight;
}timmy;
struct person david;
struct person jane;

struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
struct person timmy;
struct person david;
struct person jane;

void func1()
{
	struct person {
		char name[20];
		int gender;
		double height;
		double weight;
	};
	struct person timmy;
}
void func2()
{
	// 别名person无法在func2中使用
	struct person david;
}

// 结构声明放到函数外
struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
void func1()
{
	struct person timmy;
}
void func2()
{
	struct person david;
}

初始化结构

类似于数组可以在声明时被初始化。 int arr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 结构也能在声明时初始化。

struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
struct person timmy = { "timmy", 1, 170.00, 60.00 };
printf("%s\n", timmy.name);
printf("%d\n", timmy.gender);
printf("%.2f\n", timmy.height);
printf("%.2f\n", timmy.weight);

结构变量初始化的形式和数组初始化的形式类似。在声明时，其后跟等号与初始化列表。结构的初始化列表的写法需要注意如下4点：

初始化列表由花括号包括。
花括号内为结构成员需要被初始化的值。
初始化值按照结构成员声明时的顺序依次排列
每个初始化值之间由逗号分隔。

结构数组

struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
struct person people[3] = {
{"timmy", 1, 170.00, 60.00},
{"david", 1, 175.00, 65.00},
{"jane", 2, 165.00, 55.00}
};
for (int i = 0; i < 3; i++)
{
	struct person per = people[i];
	printf("%s ", per.name);
	printf("%d ", per.gender);
	printf("%.2f ", per.height);
	printf("%.2f\n", per.weight);
}

结构数组与基本变量数组类似，使用方括号内填数组元素个数进行声明。 struct person people[3]; 初始化列表也可用于初始化结构数组，初始化列表中依次填每个结构的初始化列表，每个结构的初始化列表之间由逗号分隔。

{
{"timmy", 1, 170.00, 60.00},
{"david", 1, 175.00, 65.00},
{"jane", 2, 165.00, 55.00}
};

使用方括号内填下标可以访问结构数组中的元素。同样地，下标也是从0开始的。 people[i] 不同于数组，可以对结构使用赋值，或使用一个结构初始化一个结构。

struct person per = people[i];
//
struct person per;
per = people[i];

嵌套结构

一个结构可以作为另一个结构的成员。例如，我们声明一个结构，用于存储通讯方式。通讯方式由电话号码，邮箱组成。现在，我们需要记录每个人员的通讯方式。可以把这个结构作为人员结构的成员

#include<stdio.h>
int main()
{
	struct contact {
		char phone[20];
		char email[20];
	};
	struct person {
		char name[20];
		int gender;
		double height;
		double weight;
		struct contact c;
	};
	struct person timmy = {
	"timmy", 1, 170.00, 60.00, {"130123456678", "timmy@xxx.com"}
	};
	printf("%s ", timmy.name);
	printf("%d ", timmy.gender);
	printf("%.2f ", timmy.height);
	printf("%.2f\n", timmy.weight);
	printf("%s\n", timmy.c.phone);
	printf("%s\n", timmy.c.email);
	return 0;
}

使用.加字段名可以访问到通讯方式结构。再次使用.加字段名即可访问其内部的成员

timmy 1 170.00 60.00
130123456678
timmy@xxx.com

指向结构的指针

指针可以指向基本数据类型或者是数组。当然，指针也可以指向结构。

struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
struct person timmy = { "timmy", 1, 170.00, 60.00 };
struct person* pTimmy = &timmy;

和往常一样，加上星号* 用于声明一个指针。使用取地址运算符& ，可以获取指针。那么怎样使用指向结构的指针呢？由于取地址& 与取值* 它们具有可逆关系，我们可以把指针先转为结构再使用。

printf("%s\n", (*pTimmy).name);
printf("%d\n", (*pTimmy).gender);
printf("%.2f\n", (*pTimmy).height);
printf("%.2f\n", (*pTimmy).weight);

由于成员运算符**.**的优先级高于取值运算符*****。为了让取值*先运算符，必须使用括号包括* pTimmy 。另外，C语言中提供了更加方便的写法，成员间接运算符**->** (*pTimmy).name等价于pTimmy->name

printf("%s\n", pTimmy->name);
printf("%d\n", pTimmy->gender);
printf("%.2f\n", pTimmy->height);
printf("%.2f\n", pTimmy->weight);

结构在函数中传递

现在，我们将结构当作参数传入函数。在函数内部修改传入的参数。

#include<stdio.h>
#include<string.h>
struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
void change(struct person per)
{
	strcpy(per.name, "david");
	per.gender = 1;
	per.height = 175.00;
	per.weight = 65.00;
}
int main()
{
	struct person timmy = { "timmy", 1, 170.00, 60.00 };
	change(timmy);
	printf("%s\n", timmy.name);
	printf("%d\n", timmy.gender);
	printf("%.2f\n", timmy.height);
	printf("%.2f\n", timmy.weight);
	return 0;
}

由于实参timmy与实参per是相互独立的。修改函数change内的 per 无法改动实参timmy

timmy
1
170.00
60.00

利用指针修改结构

在函数change内部可以通过指针，找到结构变量timmy。并且，对其进行修改。

#include<stdio.h>
#include<string.h>
struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
void change(struct person* per)
{
	strcpy(per->name, "david");
	per->gender = 1;
	per->height = 175.00;
	per->weight = 65.00;
}
int main()
{
	struct person timmy = { "timmy", 1, 170.00, 60.00 };
	change(&timmy);
	printf("%s\n", timmy.name);
	printf("%d\n", timmy.gender);
	printf("%.2f\n", timmy.height);
	printf("%.2f\n", timmy.weight);
	return 0;
}

david
1
175.00
65.00

将一个结构从函数返回

从函数返回了david的数据，并且在将其赋值给了timmy。

#include<stdio.h>
#include<string.h>
struct person {
	char name[20];
	int gender;
	double height;
	double weight;
};
struct person change()
{
	struct person per;
	strcpy(per.name, "david");
	per.gender = 1;
	per.height = 175.00;
	per.weight = 65.00;
	return per;
}
int main()
{
	struct person timmy = { "timmy", 1, 170.00, 60.00 };
	timmy = change();
	printf("%s\n", timmy.name);
	printf("%d\n", timmy.gender);
	printf("%.2f\n", timmy.height);
	printf("%.2f\n", timmy.weight);
	return 0;
}

联合

联合与结构

联合的语法非常类似于结构的语法，几乎仅仅换了一个关键词而已。想组合char、short、long long，可以像如下代码写法:

struct {
	char c;
	short s;
	long long ll;
}s;

联合char、short、long long，可以像如下代码写法:

union {
	char c;
	short s;
	long long ll;
}u;

联合，关键词为**union**

#include<stdio.h>
int main()
{
	struct {
		char c;
		short s;
		long long ll;
	}s;
	union {
		char c;
		short s;
		long long ll;
	}u;
	printf("sizeof s %d\n", sizeof(s));
	printf("sizeof u %d\n", sizeof(u));
}

sizeof s 16
sizeof u 8

对于结构来说，char占用1字节，short占用2个字节。long long占用8字节。如果它们相邻紧密排列，按理说会占用11个字节。

#include<stdio.h>
int main()
{
	struct {
		char c;
		short s;
		long long ll;
	}s;
	union {
		char c;
		short s;
		long long ll;
	}u;
	printf("&s.c %d \n", &s.c);
	printf("&s.s %d \n", &s.s);
	printf("&s.ll %d \n\n", &s.ll);
	printf("&u.c %d \n", &u.c);
	printf("&u.s %d \n", &u.s);
	printf("&u.ll %d \n", &u.ll);
}

&s.c 3537784
&s.s 3537786
&s.ll 3537792

&u.c 3537768
&u.s 3537768
&u.ll 3537768

根据地址，画出结构s各个成员的内存排布情况。char与short只留空了一个字节，而short与long long之间留空了4个字节。

这种现象被称为内存对齐，虽然会浪费一些内存空间，对齐后的数据能够被更快的访问。

联合中的成员首地址是重叠的，这意味着联合的大小为联合中最大成员的大小。

联合的性质

既然各成员之间有重叠的部分，那么存储一个成员后，将覆盖掉其他成员的数据。

#include<stdio.h>
int main()
{
	struct {
		char c;
		short s;
		long long ll;
	}s;
	union {
		char c;
		short s;
		long long ll;
	}u;
	u.c = 123;
	printf("u.c = %d\n", u.c);
	u.s = 0;
	printf("u.c = %d\n", u.c);
}

u.c = 123
u.c = 0

由于共用了一段内存，存储一个成员后，将覆盖其他成员的数据。所以，联合也被翻译为共用。

联合应用举例

有一种信息，它只有3种形态：

整数
浮点数
字符串

并且，一次只能出现一种形态。如果用结构struct来存储这种信息。而这个信息可能是整型，可能是浮点数，也可能是字符串。那么，需要准备三个不同类型的成员。由于一次只会出现一种形态，所以，每次仅用一个成员，另外两个留空。另外，需要一个整型的type成员来标记这一次是什么类型。例如：1代表整型，2代表浮点，3代表字符串。

#include <stdio.h>
struct message
{
	int type;
	int n;
	float f;
	char* str;
};
void printMsg(struct message msg)
{
	switch (msg.type)
	{
	case 1:
		printf("%d\n", msg.n);
		break;
	case 2:
		printf("%f\n", msg.f);
		break;
	case 3:
		printf("%s\n", msg.str);
		break;
	}
}
int main()
{
	struct message msg[3];
	// 第一个信息为整型，type为1
	msg[0].type = 1;
	msg[0].n = 123;
	// 第二个信息为浮点型，type为2
	msg[1].type = 2;
	msg[1].f = 3.1415926;
	// 第三个信息为字符串，type为3
	msg[2].type = 3;
	msg[2].str = "HelloWorld";
	for (int i = 0; i < 3; i++)
	{
		printMsg(msg[i]);
	}
	return 0;
}

123
3.141593
HelloWorld

很显然，每一个信息中，都有两个成员变量是空置的。但是，如果使用联合 union 就能将这三个不同类型的成员所占空间合而为一。

type成员是一定需要有的，否则无法判断是什么类型的信息。所以，它不能合并进入union。拿到消息后，同样也需要根据消息的type用不同的方式处理。确定type后，再从msg中找到union成员u，再根据类型，选择对应的成员进行处理。

#include <stdio.h>
struct message
{
	int type;
	union {
		int n;
		float f;
		char* str;
	}u;
};
void printMsg(struct message msg)
{
	switch (msg.type)
	{
	case 1:
		printf("%d\n", msg.u.n);
		break;
	case 2:
		printf("%f\n", msg.u.f);
		break;
	case 3:
		printf("%s\n", msg.u.str);
		break;
	}
}
int main()
{
	struct message msg[3];
	// 第一个信息为整型，type为1
	msg[0].type = 1;
	msg[0].u.n = 123;
	// 第二个信息为浮点型，type为2
	msg[1].type = 2;
	msg[1].u.f = 3.14159;
	// 第三个信息为字符串，type为3
	msg[2].type = 3;
	msg[2].u.str = "HelloWorld";
	for (int i = 0; i < 3; i++)
	{
		printMsg(msg[i]);
	}
	return 0;
}

123
3.141590
HelloWorld

还有一种匿名嵌套的写法。嵌套的union中没必要写明成员名u。在其后的使用中，union中的成员当做message的成员一样处理。

#include <stdio.h>
struct message
{
	int type;
	union {
		int n;
		float f;
		char* str;
	}; // 这里省去成员名u，作为匿名嵌套成员。
};
void printMsg(struct message msg)
{
	switch (msg.type)
	{
	case 1:
		printf("%d\n", msg.n); // msg.u.n省略为msg.n
		break;
	case 2:
		printf("%f\n", msg.f); // msg.u.f省略为msg.f
		break;
	case 3:
		printf("%s\n", msg.str); // msg.u.str省略为msg.str
		break;
	}
}
int main()
{
	struct message msg[3];
	// 第一个信息为整型，type为1
	msg[0].type = 1;
	msg[0].n = 123;
	// 第二个信息为浮点型，type为2
	msg[1].type = 2;
	msg[1].f = 3.14159;
	// 第三个信息为字符串，type为3
	msg[2].type = 3;
	msg[2].str = "HelloWorld";
	for (int i = 0; i < 3; i++)
	{
		printMsg(msg[i]);
	}
	return 0;
}

123
3.141590
HelloWorld

枚举

枚举只是为整形取了一个别名，让代码中不要出现数值。在之前的例子中，我们使用数字来代表消息的类别。1代表整型，2代表浮点，3代表字符串。使用数字虽然功能上完全可以达到需要的效果。但是，如果类型越来越多的情况下，人很难记住哪一个数字对应哪一种类型。所以，C语言中提供了一种特殊的整型，枚举类型。其关键词为enum。我们把数字1，2，3用有意义的英文替代，这些英文都是可以随意命名的，只要你能看到并认识它对应着什么类型就行。例如：

1对应eInteger
2对应eFloat
3对应eString

接着，把它们像结构struct类似的形式，声明在一个花括号里面。不过，关键词改为枚举enum。

#include <stdio.h>
enum msgType {
	eInteger,
	eFloat,
	eString
};
int main()
{
	printf("%d\n", eInteger);
	printf("%d\n", eFloat);
	printf("%d\n", eString);
	return 0;
}

0
1
2

eInteger 的值为0， eFloat 的值为1， eString 的值为2

让枚举从1开始

#include <stdio.h>
enum msgType {
	eInteger = 1, // 让枚举符从1开始
	eFloat,
	eString
};
int main()
{
	printf("%d\n", eInteger);
	printf("%d\n", eFloat);
	printf("%d\n", eString);
	return 0;
}

输出结果

1
2
3

指定每一个枚举中每一个成员对应的数值。

#include <stdio.h>
enum msgType {
	eInteger = 1,
	eFloat = 3,
	eString = 5
};
int main()
{
	printf("%d\n", eInteger);
	printf("%d\n", eFloat);
	printf("%d\n", eString);
	return 0;
}

1
3
5

枚举应用

#include <stdio.h>
enum msgType {
	eInteger,
	eFloat,
	eString
};
struct message
{
	enum msgType type;
	union {
		int n;
		float f;
		char* str;
	};
};
void printMsg(struct message msg)
{
	switch (msg.type)
	{
	case eInteger:  //等价于case 0
		printf("%d\n", msg.n);
		break;
	case eFloat:    //等价于case 1
		printf("%f\n", msg.f);
		break;
	case eString:   //等价于case 2
		printf("%s\n", msg.str);
		break;
	}
}
int main()
{
	struct message msg[3];
	// 第一个信息为整型，type为eInteger
	msg[0].type = eInteger;
	msg[0].n = 123;
	// 第二个信息为浮点型，type为eFloat
	msg[1].type = eFloat;
	msg[1].f = 3.14159;
	// 第三个信息为字符串，type为eString
	msg[2].type = eString;
	msg[2].str = "HelloWorld";
	for (int i = 0; i < 3; i++)
	{
		printMsg(msg[i]);
	}
	return 0;
}

使用枚举替代数字
拿到信息后，判断是哪一个枚举值
使用枚举值进行赋值

123
3.141590
HelloWorld

猜你喜欢

js给页面加style无效果的解决方法
Python配对交易策略统计套利量化交易分析股票市场|附代码数据
Oracle字符转换技术：将字符变为数字（oracle字符转换数字）
小米捐赠5000万元驰援河南雷军：郑州加油，河南挺住！
天猫精灵“三岁成人”，智能语音“二战”逼近
淘宝“秒杀”脚本
es2021 新特性
Oracle模糊匹配让两表无缝衔接（oracle两表模糊匹配）
Nature：逆转死亡？耶鲁大学开发新系统，让猪心脏骤停一小时后，器官仍然保持活性
Oracle 视图 DBA_METADATA_PROPERTIES 官方解释，作用，如何使用详细说明
数据库连接池利用DBCP优化Oracle数据库连接（dbcporacle）
给Linux服务器绑定网口卡的简单步骤（linux网口绑定）
GPT-4老板：别慌，我有一个计划，AGI未来真的很美好！
最新 WordPress 5.8 版本详细讲解
的技巧使用SQL Server命令行小技巧玩转数据库（sqlserver命令行）
ES6【笔记】

zl程序教程