结构是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。
struct tag//tag是结构体标签
{
member-list; //成员
}variable-list;//结构体的变量
例如描述一个学生:
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}; //分号不能丢
名字,年龄,性别,学号都是成员,后面的分号不能没有,至于分号前面为什么没有对应的,是因为这里可有可无,如果有了就等于这个结构体类型的一个全局变量。 成员要有明确的大小。
在声明结构的时候,可以不完全的声明。 比如:
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20], * p;
上面的两个结构在声明的时候省略掉了结构体标签(tag)。 那么问题来了?
//在上面代码的基础上,下面的代码合法吗?
p = &x;
编译器会把上面的两个声明当成完全不同的两个类型。 所以是非法的。 匿名结构体一般只能用一次。
在结构中包含一个类型为该结构本身的成员是否可以呢?
struct Node
{
int data;
struct Node next;//结构体标签后的是变量名,可以理解为int a中的a
};
//可行否?
//如果可以,那sizeof(struct Node)是多少?
在这里编译器直接就报错了,因为结构体里面有一个struct Node next,也就是说里面还有一个struct Node类型,内部还有一个int data和struct Node next,然后next里面还有一个next,无限套娃,根本确定不了这个结构体的大小。 那么我们可以放进去一个指针,指向下一个同类型结构体的地址,这样就能确定结构体的大小了。
正确的自引用方式:
struct Node
{
int data;
struct Node* next;//指针无论什么类型都是4/8个字节长度(32位4,64位8)
};
自引用基本用于链表。(以后会详细说明的)
typedef struct
{
int data;
Node* next;
}Node;
//这样写代码,可行否?
是不可行的,因为,typedef给结构体重新命名为Node,但是在该结构体里面也有一个Node,那么是先定义Node还是先运行里面的Node呢?这就类似于先有鸡还是先有蛋。
//解决方案:
typedef struct Node
{
int data;
struct Node* next;//这次里面的指针就不是未定义的了
}Node;
这个就等于把struct Node改成Node,以后就写Node就等于用了这个结构体。
有了结构体类型,那如何定义变量,其实很简单。
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 };//结构体嵌套初始化
我们已经掌握了结构体的基本使用了。 现在我们深入讨论一个问题:计算结构体的大小。
#include <stdio.h>
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
struct S3
{
double d;
char c;
int i;
};
//结构体嵌套
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
printf("%d\n", sizeof(struct S3));
printf("%d\n", sizeof(struct S4));
return 0;
}
我们先来运行一下看看结果:
如何计算? 首先得掌握结构体的对齐规则:
偏移量有点像数组的下标,对齐数的算法就是,结构体S1中char类型的大小是1,VS编译器中的默认值是8,取最小值就是1,int类型的是4,那么对齐数就是4。
这些数字就是偏移量,一个格子(一个字节)对应一个数,那么这些成员是怎么被存放到内存里的呢? 这就用到了对齐数,第一放进去的是char类型,对齐数是1,第一个成员变量无论是什么类型都要从偏移量为0开始的地方放,第二个int类型就要放在第五个格子的位置了,因为偏移量4是int类型的对齐数4的整数倍,最后一个char因为无论什么地方都是1的整数倍,所以放在int末尾就行了,最后发现目前占用了9个格子,但是总的大小必须是最大对齐数的整数倍才行,所以就又添加了三个字节大小,变成12个字节的长度。 黑色的是char类型,紫色的是int类型的,蓝色是因为不是int对齐数的整数倍添加的三个字节长度。 第一个char类型和int之间的内存格子呢?答案是,浪费掉了。
S4的结构体里面有一个结构体S3,大小是16个字节,上面的定义是取S3成员中最大的对齐数,也就是double,为8,内存里就是这样的: 黑色的是char类型,蓝色的是S3结构体类型,红色的是double类型。
为什么存在内存对齐? 大部分的参考资料都是这么说的:
这里我用32位的机器举例子,因为32位就是4个字节,所以从头开始读,一下子就会跳过4个字节,如果这两个内存中,想读int类型的,第一个从头开始,发现不是int类型直接跳过4个字节读取就可以了,但是第二个从头开始发现这4个字节当中有int类型的一部分,那么就要从char开始的四个字节中读取,其中包含int类型的前三个字节,然后到下一个点中读取int当中最后的一个字节。 也就是说第一个对齐的只读取了一次,第二个没对齐的读取了两次。 总体来说: 结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到: 让占用空间小的成员尽量集中在一起
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
S1和S2类型的成员一模一样,但是S1和S2所占空间的大小有了一些区别。
之前我们见过了 #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));
printf("%d\n", sizeof(struct S2));
return 0;
}
结论: 结构在对齐方式不合适的时候,我么可以自己更改默认对齐数。
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函数。 原因:
函数传参的时候,参数是需要压栈,会有时间和空间上的系统开销。(之前我写了一篇函数的栈帧创建与销毁) 如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大,所以会导致性能的下降。
结论: 结构体传参的时候,尽量要传结构体的地址,节省空间。
结构体讲完就得讲讲结构体实现位段的能力。
位段的声明和结构是类似的,有两个不同:
1.位段的成员必须是 int、unsigned int 或signed int 。 2.位段的成员名后边有一个冒号和一个数字。
比如:
struct A
{
int _a : 2;//分配的单位是比特位
int _b : 5;
int _c : 10;
int _d : 30;
};
A就是一个位段类型。 那位段A的大小是多少?
printf("%d\n", sizeof(struct A));
int类型是32个比特位,前三个加起来不够32,后面的加上去就够了,所以需要再次开辟一个int类型大小的空间,也就是32个比特位,所以就是八个字节,当然肯定有空间浪费的地方。
//一个例子
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;
//空间是如何开辟的?
所以结果当然是三个字节。
总结: 跟结构相比,位段可以达到同样的效果,但是可以很好的节省空间,但是有跨平台的问题存在。
这是网络部分的一些东西。
枚举顾名思义就是一一列举。 把可能的取值一一列举。 比如我们现实生活中:
一周的星期一到星期日是有限的7天,可以一一列举。 性别有:男、女、保密,也可以一一列举。 月份有12个月,也可以一一列举
这里就可以使用枚举了。
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
};
这里如果RED不初始化,BLUE不初始化,那么RED就是0,BLUD就是3。
为什么使用枚举? 我们可以使用 #define 定义常量,为什么非要使用枚举? 枚举的优点:
便于调试是最重要的,#define是替换文本,这个是在预处理的地方,正常来说我们调试的时候都是代码运行成功才能调试的
enum Color//颜色
{
RED = 1,
GREEN = 2,
BLUE = 4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值,才不会出现类型的差异。
联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员,特征是这些成员公用同一块空间(所以联合也叫共用体)。 比如:
#include <stdio.h>
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));
return 0;
}
原因往下看。
联合的成员是共用同一块内存空间的,这样一个联合变量的大小,至少是最大成员的大小(因为联 合至少得有能力保存最大的那个成员)。
#include <stdio.h>
union Un
{
int i;
char c;
};
int main()
{
union Un un;
// 下面输出的结果是一样的吗?
printf("%p\n", &(un.i));
printf("%p\n", &(un.c));
//下面输出的结果是什么?
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
}
因为公用的都是一个地址,所以前两个地址相同很正常。 至于地三个结果,下面的图片能解释:
先说明一下,我的计算机是小端存储。 一开始给int类型的结构体赋值,然后又给char赋值,我们知道联合体的成员用同一块内存空间,char类型只占一个字节,从低地址到高地址用,所以就把int类型的里面有44值的给覆盖了,变成了55,因为储存是从低地址储存的,所以也要从低地址取出来,就变成了11223355。 (这种类型的联合体也适合判断当前机器的储存方式是大端小端,大段就是55223344)
联合的大小至少是最大成员的大小。 当最大成员大小不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍。 比如:
#include <stdio.h>
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));
}
我用第一个来画图解释:
一个int长度的内存容纳不下五个char类型的元素那就在扩容一个int长度的内存用来存放剩余的,这里int的对齐数是4,char是1,所以一次就扩大4,这样就都是4的整数倍了。