结构
使用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
与{
之间可以填写一个结构别名。若以后再次需要使用这种结构,仅需要使用struct
加别名
即可声明这种结构的变量。
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));
}
结构 s 测得大小为16,而联合 u 测得大小为8
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