目录
前言:
这一篇讲解了结构体,位段,枚举,联合的使用,这些知识在编程中应用比较广泛的一类,虽然不是太难,但是有很多陷阱,比如结构体的内存对齐,位段的内存分配,联合大小的计算等等。但这些只要细心,在以后的编程路上也都不是难事。好了,先来一张美图直接开始。
一,结构体
结构体跟数组差不多,数组是一类相同类型元素的集合,而结构体可以是不同元素的集合。这些不同元素称为成员变量,结构体每个成员可以是不同类型的成员变量。
1.1结构体的声明
struct tag
{
成员变量;
}变量列表;
例如描述一个学生,学生的信息包含名字,年龄,性别,学号。如下:
struct stu
{
char name[20]; //名字
int age; //年龄
char sex[5]; //性别
char id[20]; //学号
}x; //x全局结构体变量
int main()
{
struct stu s = {"张三", 18, "男",2023666}; //初始化一个学生s
reutn 0;
}
1.2 结构体的特殊声明
特殊声明又称为不完全声明。
struct //struct后没有结构体的名字则创建的结构体成员,只能用一次
{
int a;
int b;
char c;
}x;
struct
{
int a;
int b;
char x;
}a[20],*p;
如果在上面的基础上,下面的代码合法吗?
p = &x;
非法,编译器会把上面的两个声明当成完全不同的两个类型。
1.3 结构体的自引用
什么是结构体的自引用呢,这里我们就要提及到链表了。
链表是数据结构的一种,而数据结构简单的说是数据在内存中存储的结构。比如我们要存储1,2,3,4,5这一组数,我们需要搞一个连续的空间存储,也可以每一个数在空间任意位置存储(顺序表),而这些空间要互相能够找到,比如1能找到2,2能找到3....(有两种:链表,二叉树)。
链表就像是用链子把一组数连起来而每个数都有一个节点,用来找下一个数。这样的话我们可以用结构体来实现节点。那下面的代码可行吗?
struct Node
{
int data;
struct Node next;
};
这样写到话,虽然能找到下一个节点,但是这个结构体非常危险,会变得无限大。我们可以这样设计,可以在里面放一个指向下一个节点的指针,这样的话它的大小是可控的。(指针是4或者8字节)。如下:
struct Node
{
int data;
struct Node* next;
};
所以我们要存储一些数字,可以用链表的方式。在一个数据中,也包含了下一个数据的地址,这就是结构体的自引用
1.4 结构体变量的定义和初始化
struct Point
{
int x;
int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
struct Point p3 = {x, y}; //初始化:定义变量的同时赋值
struct Stu //声明类型
{
char name[15];
int age;
};
struct Stu s = {"zhangsan",20}; //初始化
struct Node
{
int date;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6},NUll}; //结构体嵌套初始化
1.5 结构体内存对齐
结构体对齐规则:
- 第一个成员在与结构体变量偏移量为0的地址处。
- 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。对齐数 = 编译器默认的一个对齐数 与该成员大小的较小值。(vs中默认的值为8)
- 结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
- 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构的对齐数)的整数倍。
下面讲解几道练习题加深印象。
#include<stdio.h>
struct S1
{
char c1; //c1占第个字节(第一个成员在与结构体变量偏移量为0的地址处),c1,最大对齐数为1
int i; //i从最大对齐数的整数倍开始,i占第5到第8处的字节,i最大对齐数为4
char c2; //c2 从自身最大对齐数的整数倍开始,c2占第9处的地址,c2最大对齐数为1
//结构体的整体大小就是所有最大对齐数的整数倍,12
};
struct S2
{
double d; //d占第1到第8个字节,最大对齐数是 8
char c; //c占第9个字节,最大对齐数是 1
int i; //i 占第13个到16个字节。最大对齐数是4
结构体的整体大小就是所有最大对齐数的整数倍,16
};
struct S3 //结构体嵌套问题
{
char c1; //c1占第1个字节
struct S2 s2; //S2 占第9到24个字节(嵌套的结构体对齐到自己的最大对齐数的整数倍处)
double d; //d占第25到32个字节
///结构体的整体大小就是所有最大对齐数的整数倍,32
};
int main()
{
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//16
printf("%d\n", sizeof(struct S3));//32
return 0;
}
为什么存在内存对齐?
1,平台原因(移植原因):
不是所有的硬件平台都能访问任意地址上的任意数据,某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。
2,性能原因:
数据结构(尤其是栈)应尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。
总体来说:
结构体的内存对齐是拿空间来换取时间的做法。那么在设计结构体的时候,我们既要满足对齐,又要节省空间,就要让占用空间小的成员尽量集中在一起。
1.6 修改默认对齐数
预处理指令#pragma可以改变我们的默认对齐数。所以,结构在对齐方式不合适的时候,我们可以自己更爱默认对齐数。(一般设置2的倍数)
#include<stdio.h>
#pragma pack(8) //设置默认对齐数为8
struct s1
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数,还原为默认
#pragma pack(1)//设置默认对齐数为1
struct s2
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数,还原为默认
int main()
{
printf("%d\n", sizeof(struct s1));//12
printf("%d\n", sizeof(struct s2));//6
return 0;
}
1.7 结构体传参
结构体传参的时候,要传结构体的地址。
struct s
{
int data[1000];
int num;
};
struct s s = { {1,2,3,4},1000 };
//结构体传参
void printf1(struct s s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void printf2(struct s* ps)
{
printf("%d\n", ps->num);
}
int main()
{
printf1(s); //传结构体
printf2(&s); //传地址
return 0;
}
上面两种传参形式,printf2函数好一些。
因为函数传参的时候,参数是需要压栈,会有时间和空间上的系统开销。如果传递一个结构体对象的时候,结构体过大,参数压栈的系统开销比较大,所以会导致性能下降。
二,位段
位段的声明和结构是类似的,但有两个不同:
- 位段的成员必须是int , unsigned int 或 signed int.
- 位段的成员名后边有一个冒号和一个数字。
比如:
struct A
{
int _a : 2; //占2个比特位
int _b : 5; //占5个比特位
int _c : 10;//占10个比特位
int _d : 30;// 占30个比特位
};
int main()
{
printf("%d\n", sizeof(struct A));//位段A占8个字节
return 0;
}
如果位段是int型,一次开辟4个字节,如果空间不够,再申请 4个字节。如果位段是char型,一次开辟1个字节,如果空间不够,再申请 1个字节。
2.1位段的内存分配
1,位段的成员可以是int , unsigned int , unsigned int 或者是 char (属于整型家族)类型
2,位段的空间上是按照需要以4个字节(int)或者1个字节(char)的方式开辟的。
3,位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。
一个空间开辟的例子:
#include<stdio.h>
struct B
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
int main()
{
struct B s = { 0 };
s.a = 10; //二进制:00001010
s.b = 12; //二进制:00001100
s.c = 3; //二进制:00000011
s.d = 4; //二进制:00000100
printf("%d\n", sizeof(struct B)); //3
return 0;
}
2.2 位段的跨平台问题
- int 位段被当成有符号还是无符号是不确定的。
- 位段中最大位的数目不能确定。(16位机器最大16, 32位机器最大32,写成27,在16位机器会出现问题 )
- 位段中的成员在内存中从左向右分配,还是从右向左分配标准c语言没有定义。
- 当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,这是不确定的。
跟结构相比,位段可以达到同样的效果,但是可以很好的节省空间,但有跨平台问题存在。
三,枚举
枚举是把可能的取值一一列举。
3.1枚举类型的定义
enum Day //星期
{
mom,
tues,
wed,
thur,
fri,
sat,
sun
};
enum sex //性别
{
male,
female,
secret
};
enum color //颜色
{
red,
green,
blue
};
以上定义的enum Day, enum sex , enum color 都是枚举类型。{ }中的内容是枚举类型的可能取值,也叫枚举常量。这些可能取值都是有值的,默认从0开始,一次递增1,当然在定义的时候也可以赋初始值。例如:
enum color //颜色
{
red = 1,
green = 2,
blue = 4
};
3.2 枚举的优点
我们可以使用#define定义常量,为什么非要使用枚举?因为枚举有以下优点:
- 增加代码的可读性和可维护性。
- 和#define定义的标识符比较枚举有类型检查,更加严谨。
- 防止命名污染(封装)。
- 使用方便,一次可以定义多个常量。
3.3 枚举的使用
#include<stdio.h>
enum color //颜色
{
red = 1,
green = 2,
blue = 4
};
int main()
{
enum color clr = green;
clr = 5;
printf("%d\n", clr); //5
}
四,联合(共用体)
联合也是一种特殊的自定义类型,这种类型定义的变量也包含一系列的成员,特征是这些成员公用同一块空间(所以联合也叫共用体)。比如:
union un //联合类型的声明
{
char c;
int d;
};
union un un; //联合变量的定义
int main()
{
//计算整个变量的大小
printf("%d\n", sizeof(un)); //4
return 0;
}
4.1 联合的特点
联合的成员是共用同一块内存空间的,这样一个联合变量的大小,至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)。
union un //联合类型的声明
{
int d;
char c;
};
union un un; //联合变量的定义
int main()
{
//计算整个变量的大小
printf("%p\n", &(un.d)); //00007FF79EC7C174
printf("%p\n", &(un.c)); //00007FF79EC7C174
un.d = 0x11223344;
un.c = 0x55;
printf("%x\n", un.d); //11223355
return 0;
}
面试题:判断当前计算机的大小端存储:
union un //联合类型的声明
{
int d;
char c;
};
union un s;
int main()
{
s.d = 1;
s.c = 0;
if (s.c = 1)
{
printf("小端存储\n");
}
else
{
printf("大端存储\n");
}
return 0;
}
4.2 联合大小的计算
- 联合的大小至少是最大成员的大小。
- 当最大成员大小不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍7。
#include<stdio.h>
union un1
{
char c[5];
int i;
};
union un2
{
short c[7];
int i;
};
union un3
{
char i;
int c;
};
int main()
{
printf("%d\n", sizeof(union un1)); //8
printf("%d\n", sizeof(union un2)); //16
printf("%d\n", sizeof(union un3)); //4
return 0;
}
好了,到了这里就结束了,希望对大家有所帮助。