目录
1.结构体类型:
C语言中有一些类型:
内置类型: char short int long long long float double
自定义类型(自己创造出来的类型): 结构体,枚举,联合以及数组
1.结构的基础知识
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
2.结构体的声明:
结构的基础知识 : 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。(解析:结构体是把一些值组合在了一起,让它们一起作为某一个对象的属性)
为什么会有结构体?答:C语言中的内置类型往往是不够的 ,比如我要描述一个学生包括了(姓名,性别,年龄,身高) 这个地方发现学生的类型是比较丰富的,这时候我们就要定义一个复杂类型,这时候就有了结构体类型出现 结构体是一些值的集合其实是为了描述学生这个类型集合了某些值或类型,这些值被称为成员变量
//结构体的声明:
struct tag
{
member-list;
}variable-list;
//例如描述一个学生：
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}；//分号不能丢结构体类型的创建与声明一般都放在前面,如果在后面的话前面的函数就用不上了
3.特殊的声明:
在声明结构的时候，可以不完全的声明。(不完全声明比如你在创建struct的时候 不给他定义一个结构体名字 但是有成员变量,这叫匿名结构体类型,但是这种你以后想使用你就必须得在变量列表马上创建一个变量 否则以后使用不了 以后想使用也只能用创建的变量去使用且只能使用一次)
(如果在创建了一个匿名结构体并且在成员变量中定义了一个变量sa之后,再次创建一个匿名结构体类型,并且变量列表中定义一个结构体指针变量*ps,然后 ps=&sa,这样编译器会报worning *"=":从* 到 *的类型不兼容,这时候可以发现一个问题 编译器认为这是两种类型,虽然成员一模一样 但是编译器会认为这种匿名结构体是两种类型! 所以以后尽量不要这样写代码 这样写会有问题!!这样的写法是非法写法)
在声明结构的时候，可以不完全的声明。
比如：
//匿名结构体类型
struct
{
int a;
char b;
float c; }x;
struct
{
int a;
char b;
float c; }a[20], *p;// 在上面代码的基础上，下面的代码合法吗？p = & x ;
4 结构的自引用
答:可以,但是需要放的是这个数据结构类型的指针 例子如下
struct Node
{
int a[];
struct Node* next;//这个就是自己类型的指针,可以实现自己类型对象找自己类型对象
};//这样设计的话这个结构体类型的大小是可以确定的!如果放的是结构体本身而不是指针的话,那么它的大小是无法计算的,因为结构体中包含自己这个结构体那就要无限制的套用下去无限制的创建根本没法计算!
(匿名结构体类型补充 还有一种例子就是typedef struct这种匿名结构体类型重定义成Node 放在变量列表,然后成员列表放自引用的指针就放Node* next,创建的时候就直接创建Node n;如果这样去编译编译器会直接告诉你语法错误,因为typedef要对这个类型进行重定义的时候,这个类型必须是清晰可见的,必须得是存在的,虽然变量列表里面有定义一个Node,但是Node是通过typedef定义出来的,原本是没有的,相当于成员列表里面的Node原本就是不存在的,这个地方就会先后出现问题 是错误的! 如果我们想用typedef去进行重定义,并且成员列表还想要有该类型指针,那就必须得把类型名带上!否则不行)
建议不要使用匿名结构体 只能使用一次!
(另外补充,如果我们正常创建比如struct Node 我们对它重定义 typedef struct Node 定义成 Node 那么就把这个Node放到变量列表去,这样以后创建这个结构体类型变量的时候就可以直接以Node进行创建,同时struct Node也不影响也可以创建,就是缩写罢了)
(有些书上建议的是尽力不要对struct类型进行重定义,这样的话可读性不高,但是是根据实际工作情况中而定义 根据自己情况抉择)
节点的创建:
typedef struct Node
{
int data;
struct Node* next;
}Node;
int main()
{
struct Node n2 = {100,NULL}
return 0;
}5.结构体变量的定义和初始化
有了结构体类型，那如何定义变量，其实很简单。
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 data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化6 结构体内存对齐(重点经常考)
我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。
这也是一个特别热门的考点： 结构体内存对齐
(涉及到的最终一个问题就是计算结构体大小)
比如有这么个程序:
struct S1
{
char c1;
int i;
char c2;
};
int main()
{
printf("%d\n", sizeof(struct S1));
return 0;
}本来根据我们肉眼算出的大小应该是6,但结果是12 这是为什么?
有个东西叫offsetof - 是一个偏移量的意思 本身上这个是个宏
offsetof
头文件 #include <stddef.h>
返回的是一个偏移量,是一个成员在其结构体起始位置的偏移量。(offsetof可以算一个结构体的成员相较于这个结构体的起始位置的偏移量)
函数声明: size_t offset (structName(结构体名), memberName(成员名));
如果我们这样做:
printf("%d\n", offsetof(struct S1,c1)); 结果: 0
printf("%d\n", offsetof(struct S1,i)); 结果: 4
printf("%d\n", offsetof(struct S1,c2)); 结果: 8
为什么会这样子?
答:当我们在内存中存放的时候,假设我们要创建一个struct S1 s; 这个小s在内存空间中如果开辟空间 那就跟偏移量有很大关系,假设一个内存空间,有很多个字节,s对在内存中某个位置开始创建,那么第一个字节相对于起始位置的偏移量是0,第二个字节相当于起始位置的偏移量是1,第三个偏移量就是2,第四个就是3,这样一直下去,那么根据上面的结果来看 c1的位置就在s的第一个空间 偏移量就是0 i则是在第五个内存块开始分配 偏移量就是4 c2就是从第九个内存块开始 偏移量就是8 那么问题来了 中间相差的三个偏移量干嘛去了? 根据我们原本sizeof来看 其实是占了12个字节 那么目前可以确认的是已经开辟并且占用了6个字节 其中隔了3个字节开辟了但未被使用,那么可以证明在第九个内存块后面还存在了三个内存块被开辟了,但是未被使用! 这就是我们在发现结构体在创建的时候的一些问题 这就引出来一个问题叫结构体内存对齐
如何计算？
首先得掌握结构体的对齐规则：
1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的值为8 (Linux环境没有默认对齐数!Linux环境下对齐数都是成员自身大小)
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。(最大对齐数是指所有成员对齐数中最大的那个)
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
为什么存在内存对齐?
大部分的参考资料都是如是说的：
1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
问。
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起。
//例如：
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。7.修改默认对齐数
之前我们见过了 #pragma 这个预处理指令，这里再次使用，可以改变默认对齐数。
#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
}结论：
结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。(但是千万不要乱改,我们一般该的对齐数都是2的N次方)
8.结构体传参
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; }上面的 print1 和 print2 函数哪个好些？
答案是：首选print2函数。
原因：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
2.位段
1.什么是位段
位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。(规定是这样规定,但位段的成员写成char类型也没什么问题 后面会再说)
2.位段的成员名后边有一个冒号和一个数字。
2 位段的内存分配
比如：
struct A {
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};
A就是一个位段类型。
那位段A的大小是多少？
printf("%d\n", sizeof(struct A)
(用sizeof打印出来是8 为什么呢?)
答:因为
struct A {
int _a:2; (:2的意思是_a只占2个比特位)
int _b:5; (:5的意思是_c只占5个比特位)
int _c:10;(:10的意思是_a只占10个比特位)
int _d:30;(:30的意思是_a只占30个比特位)
}; (合起来就是47个比特位 那么6个字节不就好了吗,为什么要8个字节?)答:因为
1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型所以也可以作为位段的成员
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。解释:(什么意思呢,比如上面的Struct A里面的_a,那么给它一次开辟4个字节,不够了再开辟,先上来不管三七二十一,你一个整形的_a,就先给你开辟一个整形 就是开辟4个字节,你一个_a只需要两个比特位,那就拿走2个比特位,拿走2个之后还剩30个比特位,然后_b说我需要5个比特位,那么剩余的30个比特位再-5=25,然后_c需要10个比特位,那么就是剩余25-10=15,接着_d需要30个,那么剩下的比特位不够了,那么接下来再给它开辟4个字节, 那么就是又开辟了32个比特位 ps(疑问,又开辟了32个比特位,前面还剩下15个怎么办? 是先使用新的32个比特位里面的30个 还是说把前面剩下的15个也利用掉? 这地方就形成了一定的歧义和不确定) 但是不管它有没有使用前面剩余的比特位,可以确定的是又开辟了4个字节32个比特位的空间 那么两次开辟空间,总共给它开辟了8个字节,所以上面的sizeof结果是8
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。(1.比如说有这些不确定因素:新分配的比特位够剩余所有的成员使用那么前面剩余的比特位会不会使用呢? 这个C语言标准都没有规定,具体会不会使用完全取决于编译器,每个编译器又实现的不一定一样所以不具有移植性)
//(1.的)一个例子
struct S {
char a:3;
char b:4;
char c:5;
char d:4;
};
struct S s = {0};
s.a = 10; s.b = 12; s.c = 3; s.d = 4;
//空间是如何开辟的？
两种可能性:
1.a第一次开辟1个字节8个比特位,a使用3比特位剩余5比特位
b使用4比特位还剩余1比特位
c要使用5比特位不够 第二次开辟1个字节8个比特位 c使用5比特位 剩余3比特位
d要使用4个比特位,第一次剩余1和第二次剩余3比特位直接给它使用
那么如果是这个情况下 只开辟2个字节;
2.a第一次开辟1个字节8个比特位,a使用3比特位剩余5比特位
b使用4比特位还剩余1比特位
c要使用5比特位不够 第二次开辟1个字节8个比特位 c使用5比特位 剩余3比特位
d要使用4个比特位,第二次剩余的也不够 那么第三次开辟1个字节8个比特位
d使用4个比特位 第三次开辟剩下4个比特位
那么如果是这个情况下 开辟3个字节;
结果:sizeof结果是3个字节,那么就可以大概推测位段空间使用的规则是:前面剩的后面不够用的话就再开辟,前面不够用的就浪费掉
位段的作用:在一定程度上节省了空间,位段用的前提条件是在实现的时候一些细节会非常明确,比如说它明确的知道_a它的取值是什么,假设_a的取值只有4种:00 01 10 11 _a的取值无非就是这4种的话,那_a只需要2个比特位就可以描述这4种状态(这种只需要2个比特位的状态是使用者自己要明确知道_a这种存储的数据只需要2个比特位就能表明!设计的时候就这样设计),_b什么的以此类推, 这样在一定程度上就可以节省很大空间,这样的话就不用为_a开辟一个整形的空间了, 这一点描述是还没考虑上对齐的问题;
开辟字节后是先使用低权值位的比特位还是高权值的比特位 这个不确定 取决于编译器 (VS是从低权值位开始使用) 如果要存的数据 比如设定a是3个比特位 但是实际要存的数据是4个比特位的话那么就会取低权值的3个比特位存进去 比如1010 取010 如果设定的是5个比特位 但实际只要放3个比特位 就会在前面补上缺几个比特位的0 比如要存的是3 那么就是011 存的时候存的是00011
3.位段的跨平台问题
1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
总结：
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
3.枚举
枚举顾名思义就是一一列举。
把可能的取值一一列举。
比如现实生活中：
一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举
这里就可以使用枚举了。
1.枚举类型的定义
enum Day//星期
{
Mon,
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
};2.枚举的优点
为什么使用枚举？
我们可以使用 #define 定义常量，为什么非要使用枚举？
枚举的优点：
1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量
3.枚举的使用
enum Color//颜色
{
RED=1,
GREEN=2,
BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。4.联合(共用体)
1.联合类型的
联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un)); //结果为4
2.联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。
那什么情况下用联合体合适? 答:在有时候你只要用它的a成员,有时候你要用它的b成员,反正不会同时使用的时候
3 联合大小的计算
联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
比如：
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));
//第一个的结果为8,因为char类型数组开辟了5个字节 但是实际上它的对齐数是1 i的对齐数是4 所以i还是最大的对齐数,那么这个联合体中最大对齐数还是4,Un1中共开辟了5个字节,但是5不是4的整数倍,所以要再开辟3个字节 总共大小为8个字节
//第二个的结果为16 与第一个同理 i对齐数是4 c对齐数是2 i还是最大对齐数,但是c是个数组开辟了14个字节,14不是4的整数倍,所以要开辟到16为4的整数倍 故结果为16
扫一扫
619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
