文章目录
1.结构体:
1.1 结构体的概念:
结构是⼀些值(变量)的集合,这些值(变量)称为成员变量。结构的每个成员可以是不同类型的变量。
1.2 结构体的声明:
例如描述⼀个学生:
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;
警告:
,虽然两者成员相同,但编译器会把上面的两个声明当成完全不同的两个类型。
匿名的结构体类型,如果没有对结构体类型重命名的话,基本上只能使用一次。
1.3 结构体的自引用:
如果我们想在某一结构体内放一个与该结构体类型相同的成员,这是做不到的。但我们可以在该结构体中存放指向下一个同类型结构体变量的指针,而不能直接将与该结构体类型相同的结构体变量放在该结构体中。
(通俗来讲:我们无法在一栋房子中放下与这一栋房子大小相同的房子,但可以放下与这栋房子大小相同的另一栋房子的地址,通过地址也能找到这一栋房子)。
示例如下:
struct Node
{
int data;
struct Node next;
};
创建错误。因为⼀个结构体中再包含⼀个同类型的结构体变量,这样结构体变量的大小就会无穷的大,是不合理的。
而正确的创建方式:
struct Node
{
int data;
struct Node* next;//指向下一同类型结构体变量的指针
};
或者:
struct stu
{
int sc;
struct stu* now;//指向本结构体变量的指针
};
自己发现的无限套娃的方式:(仅供娱乐)
1 struct stu
2 {
3 int sc;
4 struct stu* now;
5 };
6 int main()
7 {
8 struct stu a = {4,&a};
9 if ((((a.now)->now)->now)->now == &a)
10 {
11 printf("yes");
12 }
13 return 0;
14 }
通过第8行:将a的地址传给结构内部指向自己的指针now。
第9行:用指向该结构体的指针(a.now)访问指向自己的指针((a.now)->now),拿着该指针继续访问指向自己的指针…(无限进行下去)最后判断最终结果还是该结构体的地址(指向改结构体的指针)。
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 data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化
1.5 结构体内存对齐:
1.5.1 对齐规则:
1. 结构体的第一个成员对齐到相对结构体变量起始位置偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址(偏移量)处。
对齐数 = 编译器默认的一个对齐数与该成员变量大小的较小值。
VS中默认的值为8。
Linux中没有默认对齐数,对齐数就是成员自身的大小。
3.结构体总大小为最大对齐数(结构体中每个成员变量都有一个对齐数,所有对齐数中最大的)的
整数倍。
4.如果嵌套了结构体的情况,嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体中成员的对齐数)的整数倍。
来看下面几个例子:
例1:
//例1
struct S1
{
char c1;
int i;
char c2;
};
c1为char型,对齐到偏移量为0处。
i为int型,对齐数为4,对齐到偏移量为4处。
c2为char型,对齐到偏移量为8处。
最大对齐数为4,而现在已经占了9字节,所以该结构体至少占4*3=12字节(也就是12字节),图示如下:
例2:
//例2
struct S2
{
char c1;
char c2;
int i;
};
c1为char型,对齐到偏移量为0处。
c2为char型,对齐到偏移量为1处。
i为int型,对齐数为4,对齐到偏移量为4处。
最大对齐数为4,而现在已经占了8字节,所以该结构体至少占4*2=8字节(也就是8字节),图示如下:
例3:
//例3
struct S3
{
double d;
char c;
int i;
};
d为double型,对齐到偏移量为0处。
c2为char型,对齐到偏移量为8处。
i为int型,对齐数为4,对齐到偏移量为43=12处(前8字节内存已经被占用,至少对齐到偏移量为12的的地方)。
最大对齐数为8,而现在已经占了16字节,所以该结构体至少占82=16字节(也就是16字节),图示如下:
例4.
//例4
struct S4
{
char c1;
struct S3 s3;
double d;
};
char为double型,对齐到偏移量为0处。
s3为结构体,其对齐数为结构中的最大对齐数(8),应对齐到81=8处。
d为double型,对齐数为8,应对齐到83=24处(前24字节内存已经被占用,至少对齐到偏移量为24(第25字节)的的地方)。
最大对齐数为8(嵌套结构体中的double和外层结构体中的double都是8字节),而现在已经占了32字节,所以该结构体至少占8*4=32字节(也就是32字节),图示如下:
1.5.2 存在内存对齐的原因:
- 平台原因(移植原因):
不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。 - 性能原因:
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要做两次内存访问;而对齐的内存访问仅需要⼀次访问。假设⼀处理器总是从内存中取8个字节,则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数,那么就可以用⼀个内存操作来读或者写值了。否则,我们可能需要执行两次内存访问,因为对象可能被分放在两个8字节内存块中。
总体来说:结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候,我们既要满足对齐,又要节省空间,就要:
让占用空间小的成员尽量集中在一起。
例如:
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
S1 和 S2 类型的成员⼀模⼀样,但是 S1 和 S2 所占空间的大小有了一些区别。
1.5.3 修改默认对齐数:
#pragma 这个预处理指令,可以改变编译器的默认对齐数。
#pragma pack(1)//设置默认对⻬数为1
struct S
{
char c1;
int i;
char c2;
};
1.6 结构体传参:
结构体传参有两种方式:传结构体整体与传地址。
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.函数传参的时候,参数是需要压栈,会有时间和空间上的系统开销。
2.如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大,所以会导致性能的下降。
结论:
结构体传参的时候,要传结构体的地址。
1.7 结构体实现位段:
1.7.1 什么是位段:
位段的声明和结构是类似的,有两个不同:
1. 位段的成员必须是 int、unsigned int 或signed int ,在C99中位段成员的类型也可以选择其他类型。
2. 位段的成员名后边有⼀个冒号和⼀个数字。
例如:
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};
这里的数字代表的是比特位(bit)
1.7.2 位段的内存分配:
- **位段的成员可以是 int unsigned int signed int 或者是 char 等类型。
- 位段的空间上是按照需要以4个字节( int )或者1个字节( char )的方式来开辟的。
- 位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。**
一个例子:
//⼀个例⼦
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;
//空间是如何开辟的?
在当前(vs2013)环境下,位段在一个字节中由高地址到低地址创建,如果空间不够(一个字节无法装下),则舍弃剩下的空间,另开辟空间。
1.7.3 位段使用的注意事项:
位段的几个成员共有同⼀个字节,这样有些成员的起始位置并不是某个字节的起始位置,那么这些位置处是没有地址的。内存中每个字节分配⼀个地址,⼀个字节内部的bit位是没有地址的。
所以不能对位段的成员使用&操作符,这样就不能使用scanf直接给位段的成员输入值,只能是先输入放在⼀个变量中,然后赋值()给位段的成员。
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
struct A sa = {0};
scanf("%d", &sa._b);//这是错误的
//正确的⽰范
int b = 0;
scanf("%d", &b);
sa._b = b;
return 0;
}
2. 联合体:
2.1 联合体的声明:
像结构体⼀样,联合体也是由⼀个或者多个成员构成,这些成员可以不同的类型。但是编译器只为最大的成员分配足够的内存空间。联合体的特点是所有成员共用同⼀块内存空间。所以联合体也叫:共用体。
给联合体其中一个成员赋值,其他成员的值一般也跟着变化。
#include <stdio.h>
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un = {0};
//计算连个变量的⼤⼩
printf("%d\n", sizeof(un));
return 0;
}
结果输出为4,为什么呢?
2.2 联合体的特点:
联合的成员是共用同⼀块内存空间的,这样⼀个联合变量的大小,至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)。
//代码1
#include <stdio.h>
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un = {0};
// 下⾯输出的结果是⼀样的吗?
printf("%p\n", &(un.i));
printf("%p\n", &(un.c));
printf("%p\n", &un);
return 0;
}
//代码2
#include <stdio.h>
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un = {0};
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
return 0;
}
输出的结果:
001AF85C
001AF85C
001AF85C
11223355
代码1输出的三个地址⼀模⼀样,代码2的输出,我们发现将i的第4个字节的内容修改为55了。我们仔细分析就可以画出,un的内存布局图。
2.3 联合体大小计算:
有如下准则:
1.联合的大小至少是最大成员的大小。
2.当最大成员大小不是最大对齐数(类型大小)的整数倍的时候,总大小为最大类型大小的最小整数倍。
#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));//8
printf("%d\n", sizeof(union Un2));//16
return 0;
}
3. 枚举类型:
3.1 枚举类型的声明:
例如:
enum Day//星期
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex//性别
{
MALE,
FEMALE,
SECRET
};
以上定义的 enum Day , enum Sex 都是枚举类型。
{}中的内容是枚举类型的可能取值,也叫枚举常量 。
这些可能取值都是有值的,默认从0开始,依次递增1,当然在声明枚举类型的时候也可以赋初值。
enum Color//颜⾊
{
RED=2,
GREEN=4,
BLUE=8
};
3.2 枚举类型的优点:
我们可以使用 #define 定义常量,为什么非要使用枚举?
枚举的优点:
1. 增加代码的可读性和可维护性。
2. 和#define定义的标识符比较枚举有类型检查,更加严谨。
3. 便于调试,预处理阶段会删除 #define 定义的符号。
4. 使用方便,⼀次可以定义多个常量。
5. 枚举常量是遵循作用域规则的,枚举声明在函数内,只能在函数内使用。
3.3 枚举类型的使用:
enum Color//颜⾊
{
RED=1,
GREEN=2,
BLUE=4
};
enum Color clr = GREEN;//使⽤枚举常量给枚举变量赋值
那是否可以拿整数给枚举变量赋值呢?在C语言中是可以的,但是在C++是不行的,C++的类型检查比较严格。