嗨嗨大家好啊!今天带来的内容是:结构体、枚举与联合。话不多说,我们直接进入知识的海洋。
一、结构体
1 结构体的声明
1.1 基本概念
结构是一些值的集合,这些值称为成员变量。数组也是一些值的集合,两者的不同之处在于:结构的每个成员可以是不同类型的变量,数组是一组相同类型元素的集合。而结构的成员可以是标量、数组、指针,甚至是其他结构体。
1.2 结构的声明
struct tag
{
member-list;
}variable-list;
tag是根据实际情况进行命名的,member-list是成员变量的列表,variable-list是变量列表。
//例如描述一个学生:
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}s1,s2;//分号不能丢
s1,s2是用该结构体类型创建的变量,在主函数外部创建的变量是全局变量,在主函数内部创建是局部变量。
1.3 匿名结构体类型
//我们还是以上面的代码为例:
struct
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}s1,s2;//分号不能丢
#include <stdio.h>
struct
{
char a[20];
int b[10];
}x;
struct
{
char a[20];
int b[10];
}a[20],*p;
int main()
{
p = &x;
return 0;
}
编译上面的代码,编译器会出现如下警告 :
这说明虽然这两个结构体成员相同,但编译器会把上面的两个声明当成完全不同的两种类型,所以是非法的。
注意:匿名结构体只能使用一次,在创建时就要有变量,相当于全局变量。
2 结构的自引用
我们先来观察下面的(1)代码:
struct Node
{
int data;
struct Node next;
};
通过这个代码,来提出一个问题:在结构中包含一个类型为该类型本身的成员是否可以呢 ?下面我们进入正题。
自引用方式:
struct Node
{
int data;
struct Node* next;
};
如上(2)代码,结构体类型是 struct Node,里面的成员变量 struct Node* next 是一个指向struct Node类型数据的指针。下面以画图的形式便于大家理解它的存储结构:
该结构体包含的指针能找到本身类型的另外一个数据,实现了链表的功能,这便是结构的自引用。
现在回到刚刚提出的问题,在 (2)的代码中,结构成员使用指向 struct Node 类型的指针来找到相应数据,从而达到结构的自引用效果,也就是说,此时结构体成员的类型变为了struct Node *,不是struct Node;在(1)的代码中,结构体成员的类型与结构的类型相同,均是struct Node,这并不可行。
3 结构体变量的定义和初始化
//定义
struct Point
{
int x;
int y;
}p1;//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2
//初始化:定义变量的同时赋初值
struct Stu//类型声明
{
char name[20];//名字
int age;//年龄
};
struct Stus={"lisikui",20};//初始化
//嵌套初始化:
struct Node
{
int data;
struct Pointp;
struct Node* next;
}n1={10,{4,5},NULL};//结构体嵌套初始化
struct Node2={20,{5,6},NULL};//结构体嵌套
4 结构体内存对齐
让我们来思考一个问题:结构体怎样计算大小呢?
首先需要掌握结构体的对齐规则:
1、第一个成员在结构体变量偏移量为0的地址处。
2、其他结构体成员变量要对其到对齐数(编译器默认的对齐数与该成员类型大小的较小值)的整数倍的地址处。(vs的默认对齐数为8,部分编译器没有默认对齐数。默认对齐数可以通过预处理命令#pragma更改。)
3、每个结构体大小总为该结构体最大对齐数的整数倍。
4、在嵌套了结构体的情况下,嵌套的结构体对齐到自己最大对齐数的整数倍处,这个结构体的大小就是包括嵌套结构体的最大对齐数的整数倍。
或许文字描述难以理解,下面通过画图为大家解释:
计算结构体大小:
第一个字节相对于起始的地址偏移量为0,后面依次+1,由对齐规则可知:c1大小为一个字节,在与结构体变量偏移量为0的位置;c2大小为一个字节,小于默认对齐数8,整数倍为1,放在与结构体变量偏移量为1的位置;i大小四个字节,小于默认对齐数8,整数倍为4,放在与结构体变量偏移量为4~7的位置;结构体总大小为最大对齐数(i的对齐数为4)的整数倍,即结构体总体大小为8个字节。
下面检验我们的偏移量计算是否正确
#include <stdio.h>
#include<stddef.h>
struct s1
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", offsetof(struct s1, c1));
printf("%d\n", offsetof(struct s1, c2));
printf("%d\n", offsetof(struct s1, i));
return 0;
}
那么为什么会存在内存对齐这种现象呢?
大部分的参考资料都是如是说的:
1. 平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常;
2. 性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。
struct S
{
char c;
int i;
};
struct S s;
在32位机器下,若无内存对齐,访问i则需要访问两次,有内存对齐时访问一次便可访问到i
总体来说:结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到让占用空间小的成员尽量集中在一起呢?默认对齐数是可以修改的,之前我们见过了#pragma这个预处理指令,这里我们便使用一下,可以改变默认对齐数。
未改变默认对齐数时:
#include<stdio.h>
struct S
{
char c;
double i;
};
int main()
{
printf("%d\n", sizeof(struct S));
return 0;
}
c:0;i:对齐数为8,8~15;最大对齐数:8;总体大小:16
当我们改变默认对齐数时:
#include<stdio.h>
#pragma pack(4)
struct S
{
char c;
double i;
};
int main()
{
printf("%d\n", sizeof(struct S));
return 0;
}
c:0;i:对齐数为4,4~11;最大对齐数:4;总体大小:12
结论:当结构的对齐方式不合适时,我们可以自己修改默认对齐数。
5 结构体传参
#include<stdio.h>
struct S
{
int data[1000];
int num;
};
struct S s = { {1,2,3,4},1000 };
//结构体传参
void print1(struct S s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S*ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s);//传结构体
print2(&s);//传地址
return 0;
}
选择传址调用的原因:
函数传参的时候,参数是需要压栈,会有时间和空间上的系统开销。如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大,所以会导致性能的下降。
结论:结构体传参的时候,要传结构体的地址。
6 位段
6.1 位段的概念
C语言允许在一个结构体中以位为单位来指定其成员所占内存长度,这种以位为单位的成员称为位段。
位段的声明和结构大致相同,有两个不同之处在于:
1、位段的成员名后面有冒号和一个数字(给该成员赋给的bit空间,当没有冒号和数字时,则会开辟这个类型相对应的字节空间);
2、位段的成员类型只能是int,unsigned int,signed int,char。
//例如:
struct A
{
//1byte=8bit
int_a:2;
int_b:5;
int_c:10;
int_d:30;
};
A的大小为:
printf("%d\n",sizeof(struct A));
6.2 位段的内存分配
内存的分配规则:
1、位段的成员类型只能是 int,unsigned int,signed int 或 char(属于整型家族)。
2、位段的空间开辟是以4个字节(int)或者1个字节(char)的方式来开辟的。
3. 位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段
#include<stdio.h>
struct S
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
int main()
{
struct S s = { 0 };
printf("%d\n", sizeof(struct S));
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
return 0;
}
下面来进行画图分析:
综上,在内存中开辟3个字节分别用来存放:62 03 04
6.3 位段的跨平台问题
1. int 位段被当成有符号数还是无符号数是不确定的;
2. 位段中最大位的数目不能确定。(16位机器最大16,32位机器最大32,写成27,在16位机器会出问题;
3. 位段中的成员在内存中从左向右分配,还是从右向左分配标准尚未定义;
4. 当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,这是不确定的。
总结:跟结构相比,位段可以达到同样的效果,但是可以很好的节省空间,但是有跨平台的问题存在。
二、枚举
枚举顾名思义就是一一列举
把可能的取值一一列举
比如我们现实生活中:
一周的星期一到星期日是有限的7天,可以一一列举
性别有:男、女、保密,也可以一一列举
月份有12个月,也可以一一列举
1 枚举的定义
#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);
}
{ } 中的内容是枚举类型的可能取值,也叫枚举常量。这些可能取值都是有值的,默认从0开始,一次递增1,当然在定义的时候也可以赋初值,若给Mon赋值为1,后面会自动增加。
2 枚举的优点
我们可以使用#define定义常量,为什么非要使用枚举?
枚举的优点:
1. 增加代码的可读性和可维护性;
2. 与#define定义的标识符比较枚举有类型检查,更加严谨;
3. 防止了命名污染(封装);
4. 便于调试;
5. 使用方便,一次可以定义多个常量。
3 枚举的使用
enum Color
{
RED=1,
GREEN=2,
BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值,才不会出现类型的差异。
clr = 5;
三、联合(共同体)
1 联合类型的定义
联合也是一种特殊的自定义类型,这种类型定义的变量也包含一系列的成员,特征是这些成员共用同一块空间(所以联合也叫共用体)。
union Un
{
char c;
int i;
};
union Un un;
int main()
{
printf("%d\n", sizeof(un));
printf("%d\n", &(un));
printf("%d\n", &(un.c));
printf("%d\n", &(un.i));
}
上述代码所运行的结果说明它们的地址都是相同的,c和i在第一个字节上共用空间,有部分空间会重叠 。如下图:
2 联合的特点
联合的成员是共用同一块内存空间的,这样一个联合变量的大小,至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)。
union Un
{
char c;
int i;
};
union Un un;
int main()
{
printf("%d\n", &(un.c));
printf("%d\n", &(un.i));
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
}
上述代码中44被修改成55,因此在改c的值的时候i的值也被改变 。
我们在上一篇文章:
http://t.csdnimg.cn/FBXYv
中讲解了”如何判断当前计算机的大小端存储方式“,今天我们利用联合来学习第二种方法实现:
若返回1,则是小端存储;若返回0,则是大端存储,分析如下图:
int check_sys()
{
union Un
{
char c;
int i;
}u;
u.i = 1;
return u.c;
}
int main()
{
int ret = check_sys();
if (ret == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
}
3 联合大小的计算
联合的大小至少是最大成员的大小
当最大成员大小不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍
//比如
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
int main()
{
//下面输出的结果是什么?
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));
return 0;
}
我们以Un1为例进行分析,联合(共用体)也存在对齐,联合最大成员的大小是5,而最大对齐数是4,此时最大成员大小(5)不是最大对齐数(4)的整数倍,因此要向后对齐到8
好啦~今天的分享就到这里啦,最后的最后我想对大家说:不必急功近利,因为付出总会有回报!如果你们觉得这篇文章对自己有帮助,记得给博主一个三连哈,你们的支持是我创作的最大动力!!望大家加油,不负自己!