结构体

结构体的初阶知识在之前的博客里已经讲过了，本片文章我们做一些复习，来回顾一下结构体的基本知识
结构体初阶

结构体的声明

结构体的声明如下

struct tag
{
    
    
member-list;
}variable-list;

假设我们要用结构体来描述一个学生

struct Stu
{
    
    
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}; //分号不能丢

特殊的声明

有一种特殊的结构体声明方式叫匿名结构体
举个例子

struct S//把S去掉就是匿名结构体
{
    
    
int a;
char b;
float c;
}x;

匿名结构体在语法上是支持的，但是匿名结构体有一个缺点，那就是只能在struct后添加，即只能为全局变量。在其他地方不能再使用这个类型了。

那么我们能否再创建一个匿名结构体指针然后将这个匿名结构体的地址放进去呢？

struct
{
    
    
int a;
char b;
float c;
}x;
struct 
{
    
    
int a;
char b;
float c;
}* ps;

int main
{
    
    
ps=&x;//?
}

答案是不行的，这是因为编译器会把上面的两个声明当成完全不同的两个类型。
所以是非法的。

结构的自引用

其实这个结构的自引用就和数据结构中的链表联系起来了，一个节点除了存放自己的数据，还要能找到下一个节点。我们首先想到的是把下一个节点直接放到这个节点里，
看下面这段代码

struct Node
{
    
    
int data;
struct Node next;
};

乍一看没什么问题，实际上这样是行不通的.,因为每一个next都会有下一个节点的data，这样就会无限循环下去。很显然是有问题的。

扫描二维码关注公众号，回复： 14762236 查看本文章

正确的方法是存放下一个结点的地址。因为一个地址不是四个就是八个字节，这样一个结点的大小就可以确定了

//正确写法
struct Node
{
    
    
int data;
struct Node* next;
};

typedef的使用

我们来看这两段代码

struct 
{
    
    
int a;
char b;
float c;
} x;

typedef struct 
{
    
    
int a;
char b;
float c;
} x;

注意！这两个x所表示的含义是完全不一样的。第一个x是一个匿名结构体变量，而第二个x是一个结构体类型

我们以刚刚的节点创建为例
先来看下面这段代码

typedef struct
{
    
    
int data;
Node* next;
}Node;
//这样写可以吗？

答案是不行的，因为在大括号内时这个结构体还并没有被重命名为Node,所以不能直接用Node*，由此可见，在这种情况下是不建议用匿名结构体的，就老老实实的写

typedef struct Node
{
    
    
int data;
struct Node* next;
}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};//结构体嵌套初始化

结构体的内存对齐

这个知识点很重要！一定要理解通透！
我们来看下面这三段代码，思考这三个结构体的大小是多少？

struct S1
{
    
    
char c1;
int i;
char c2;
};
printf("%d\n", sizeof(struct S1));
//练习2
struct S2
{
    
    
char c1;
char c2;
int i;
};
printf("%d\n", sizeof(struct S2));
//练习3
struct S3
{
    
    
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct S3));
//练习4-结构体嵌套问题
struct S4
{
    
    
char c1;
struct S3 s3;
double d;
};
printf("%d\n", sizeof(struct S4));

以第一段代码为例，我们的定式思维可能会认为就是把结构体的成员变量每个的类型大小相加即可，即1(char)+4(int)+1(char)=6。但事实真的是这样吗，我们在编译器上运行一下看看。
如图1

答案居然是12，很显然，编译器一定不会出错，那么我们就要搞清楚这其中的原理是什么。
我们来看对齐的规则：

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
（VS中默认的值为8,gcc环境下没有默认对齐数）
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

我们现在就以第一段代码为例来讲解
看图2

如果有嵌套呢？看图3

到这里我们就将4条对齐规则讲解完了。

为什么存在内存对齐？

平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问.

总体来说：
结构体的内存对齐是拿空间来换取时间的做法。

思考：我们如何做到既满足对齐，又能尽可能节省空间呢？
通过前面几个例子我们发现，像char类型这种占用空间小的总是在浪费空间。所以我们要让占用空间小的成员尽量集中在一起。这样可以有效减少空间的浪费。

修改默认对齐数

#pragma 这个预处理指令,可以修改我们的默认对齐数。

举个例子

#pragma pack(8)//设置默认对齐数为8
struct S1
{
    
    
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

在修改默认对齐数时不要使用奇数倍的对齐数，这是很不合常理的。

结构体传参

结构体传参，传值调用和传址调用的选择以及压栈操作也在之前的博客中有详细讲解，这里也不过多赘述，只是回顾一下即可。

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;
}

位段

位段的声明和结构是类似的，但有两个不同
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

看下面这段代码

struct A
{
    
    
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
int main()
{
    
    
	printf("%d\n", sizeof(struct A));
	return 0;
}

这段代码打印的结果是多少呢？
如图4

我们发现是8个字节，比原本的四个int（即16个字节）节省了将近一般的空间。
那么它到底是如何开辟空间的呢？这是我们接下来要探讨的

位段的内存分配

规则如下

位段的成员可以是 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;

位段的跨平台问题

int 位段被当成有符号数还是无符号数是不确定的。
位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
器会出问题。
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的。

总的来说：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

枚举

把可能的值一一列举出来就叫做枚举
在C语言中我们通过关键字enum来实现枚举

举几个例子

enum Day//星期
{
    
    
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex//性别
{
    
    
MALE,
FEMALE,
SECRET
}；
enum Color//颜色
{
    
    
RED,
GREEN,
BLUE
};

这里面的Mon，Tues，MALE,FEMALE本质上都是数字，
我们以星期为例，打印结果如下

我们发现枚举的可能取值是默认从0开始递增1的。我们也可以通过赋值来修改默认值。

枚举在提高代码可读性这方面有明显优势，比如在switch语句中，我们输入0，1，2，3等不同数字时对应不同的后续操作，但是只是一些数字导致代码的可读性并不是那么的高但如果我们把对应的值修改为具体的操作名，那么代码的可读性就大大的提高了。这点作用在通讯录的书写中有明显的体现。

联合

联合类型的定义

联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）

联合在内存中开辟空间

我们先来来看一段代码

union Un
{
    
    
int i;
char c;
};
union Un un;
// 下面输出的结果是一样的吗？
printf("%d\n", &(un.i));
printf("%d\n", &(un.c));

可见，i和c两个变量占用了同一块空间，我们通过画图来辅助理解

我们可以通过联合体的这个特性来辅助我们判断机器的大小端
代码如下

union Un
{
    
    
	int i;
	char c;
};
union Un un;
int main()
{
    
    
	union Un u;
	u.i = 1;
	if (u.c == 1)
	{
    
    
		printf("小端");
	}
	else
	{
    
    
	    printf("大端");
	}
}

联合大小的计算

联合体同样是存在对齐的
看下面这段代码

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));
}

打印结果如图
图10
在计算联合大小的时候也有以下规律
1，联合的大小至少是最大成员的大小。
2，当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

以上就是关于自定义类型详解的全部内容了，如有出入，欢迎指正。

C语言--自定义类型详解

目录

结构体