C语言中的自定义类型--结构体（1）

引子

通过之前的学习，我们知道了一个数组是一些相同类型元素的集合。若我们需要描述一个比较复杂的变量，同时该变量包含了多种类型的数据，此时我们应该怎么描述这个变量呢？

此时我们就可以通过使用结构体变量来完成这一任务

有关结构体的基本知识

1.1结构体的定义

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量

1.2结构体的声明形式

结构体的声明形式如下：

struct tag
{
    member-list;//member--成员
}variable-list;//variable--变量

其中tag表示结构体变量的名称，可以自定义命名；

member-list为成员列表，可以自定义多种类型的变量；

variable-list为变量列表，可以创建结构体变量；

直接描述可能会比较抽象，下面来举一个例子：

若要描述一个学生的相关信息，其中包含学生的姓名，学号，年龄等，我们此时可以创建一个名叫Stu的结构体：

​
struct Stu
{
	char name[20];
	int age;
	char id[20];
}s1,s2,s3;

​

此时我们就创建好了三个变量，分别是s1,s2,s3；

除此之外。还有另外一个创建变量的方式

struct Stu
{
	char name[20];
	int age;
	char id[20];
};

struct Stu s1, s2, s3;

这样也可以创建三个结构体变量，注意两种创建变量的方法都不能丢掉分号（；），丢掉分号会造成语法上的错误

1.2*结构体的特殊声明

我们在声明结构体的时候，可以进行不完全声明，如匿名结构体类型：

struct
{
	char name[20];
	int age;
	char id[20];
}s1,s2,s3;

这种形式不包含结构体的名称，仅仅在结构体的末尾创建一次变量，只能使用一次

此时来举一个例子，我们同时创建两个匿名结构体变量，且结构体成员相同：

struct
{
	char name[20];
	int age;
	char id[20];
}s;


struct
{
	char name[20];
	int age;
	char id[20];
}*p;

int main(void)
{
	*p = &s;
	return 0;
}

运行程序报错：

虽然两个结构体变量的成员和参数相同，但是两个结构体变量并不相同。编译器把上述的两个变量当作了完全不同的变量，这就间接的告诉了我们匿名结构体变量仅会使用一次

*1.3结构体的自引用（关联数据结构，仅作了解）

数据结构：数据在内存中的组织结构，包括线性数据结构和树形数据结构，我们来重点分析线性数据结构。

线性数据结构：假设要在内存之中存储1，2，3，4，5，方法一：可以直接将其在连续的一块内存空间里直接存入内存，这种连续的存储方式称为顺序表；方法二：可以在内存中创建5个毫无关联的内存空间，相邻的变量之间可以通过前一个变量来找到后一个变量，以此来贯穿所有数据，这种存储方式叫做链表，每一个存储数据的变量叫做节点

每个节点里面既要包含自己的数据，又要包含一个变量用于找到下一个节点，此时有的同学就会想到要这样编写：

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

但事实上。这样的编写方式是错误的，因为struct Node next会往后无限创建，导致sizeof（Node）的大小不固定并且无限增大，我们应该这样改：

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

用上一个节点包含下一个节点的地址，这样sizeof(Node)的大小就是固定的了，存放数据的变量叫做数据域，存放指针的变量叫做指针域

在结构体⾃引⽤使⽤的过程中，夹杂了typedef对匿名结构体类型重命名，也容易引⼊问题，看看下⾯的代码，可⾏吗？

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

这样的写法是错误的，因为结构体里面的成员运用了结构体Node，而Node是对前⾯的匿名结构体类型的重命名产⽣的，要在匿名结构体外提前创立Node

所以改进方案如下：

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

1.4结构体的初始化

struct Stu
{
	char name[20];
	int age;
	char id[20];
}s1 = { "zhangsan",18,"01" }, s2 = { .age = 15,.id = "02",.name = "wangwu" };


int main(void)
{
	struct Stu s3 = { "lisi",16,"03" };
	printf("%s %d %s\n", s1.name, s1.age, s1.id);
	printf("%s %d %s\n", s2.name, s2.age, s2.id);
	printf("%s %d %s\n", s3.name, s3.age, s3.id);
	return 0;
}

在初始化是可以用"."来找到结构体里面的成员，从而进行不按顺序的初始化，将数据打印或者写入数据时也需要通过"."来找到对应的成员

当结构体里面也包含有结构体的时候，此时我们需要通过下面这种形式找到结构体成员：

struct Stu
{
	char name[20];
	int age;
	char id[20];
};


struct S
{
	int num;
	struct Stu a;
};



int main(void)
{
	struct S s1 = { 0,{"zhangsan",18,"01"} };
	
	printf("%s %d %s %d\n", s1.a.name, s1.a.age, s1.a.id, s1.num);
	return 0;
}

初始化结构体里面的结构体成员时，需要在{ }里面再加入{ }

找到结构体里面的结构体成员时，需要先用"."找到结构体里面的结构体变量，再用一次"."来找到结构体里面的结构体成员

1.5结构体的内存对齐（计算结构体的大小）

struct S1
{
	char c1;
	int i;
	char c2;
};

struct S2
{
	char c1;
	char c2;
	int i;
};


int main(void)
{
	printf("sizeof(struct S1) = %d\n", sizeof(struct S1));
	printf("sizeof(struct S2) = %d\n", sizeof(struct S2));

	return 0;
}

当我们见到一个这样的代码，我们下意识地就会觉得sizeof(S1)和sizeof(S2)都等于4 + 1 + 1 = 6个字节，然而当我们运行程序的时候却得出了一个令人意外的结果：

这是为什么呢？此时我们就需要了解结构体在内存中是怎么进行存储的

在正式开始之前，我们先提前介绍一个宏--offsetof( ),该宏需要包含头文件<stddef.h>，宏可以传输类型，而函数不可以传输类型，它可以计算结构体成员相较于结构体起始位置的偏移量，C++官网的解释如下图：

接下来我们来介绍偏移量的概念，直接说定义可能有点抽象，我们用例子来说明吧。如图，第一个字节相较于起始位置的偏移量为0，第二个字节相较于起始位置的偏移量为1，以此类推

#include <stddef.h>
struct S1
{
	char c1;
	int i;
	char c2;
};

struct S2
{
	char c1;
	char c2;
	int i;
};


int main(void)
{
	printf("%d\n", offsetof(struct S1, c1));
	printf("%d\n", offsetof(struct S1, i));
	printf("%d\n", offsetof(struct S1, c2));

	printf("\n");

	printf("%d\n", offsetof(struct S2, c1));
	printf("%d\n", offsetof(struct S2, i));
	printf("%d\n", offsetof(struct S2, c2));
}

我们在屏幕上打印两个结构体的所有成员的偏移量，得到图如下：

通过上述情况进行分析，我们发现结构体成员并不是按照顺序在内存中连续存放，为什么会产生这样的对齐规则呢？

我们来进一步了解一下

结构体内存的对齐规则：

1.结构体的第一个成员永远放在相较于结构体起始位置偏移量为0的位置上

2.从第二个成员开始，往后的所有成员对齐到某个对齐数的整数倍处

对齐数：结构体成员的自身大小和默认对齐数的较小值，vs上的默认对齐数是8，GCC编译器上没有默认对齐数，对齐数就是结构体成员的自身大小

3.结构体的总大小必须是最大对齐数的整数倍，最大对齐数是所有结构体成员中对齐数的最大数

4.若嵌套了结构体，则该结构体对齐到自己的最大对齐数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。（如后面例题2）

练习

struct S3
{
	double a;
	char b;
	int c;
};

int main(void)
{
	struct S3 s3 = { 0 };
	printf("%d\n", sizeof(s3));
	return 0;
}

因为 double 类型占用8个字节， char 类型占用1个字节， int 类型占用4个字节，我们就可以知道，最大对齐数是8，由此进一步推算出结构体大小为16个字节

练习二

struct S3
{
	double a;
	char b;
	int c;
};

struct S4
{
	char d;
	struct S3 s3;
	double e;
};

int main(void)
{
	struct S4 s4 = { 0 };
	printf("%d\n", sizeof(s4));
	return 0;
}

此题目反映嵌套结构体的大小

若结构体中出现数组，举个例子，int arr[10] 则可以将其当作连续排列的10个整形元素处理

为什么存在内存对齐的情况

根据网络上面的资料可以知道：

存在内存对齐往往被认作有两个原因

1. 平台原因(移植原因)：

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定 类型的数据，否则抛出硬件异常。

2. 性能原因：

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要 作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地 址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以 ⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两 个8字节内存块中。

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

下面我来笼统的解释一下吧，我们不妨设结构体没有内存对齐，若存在这样的结构体

struct S
{
    char a;
    int b;
};

若其不存在对齐数，则它在空间中应该以下面这种情况存放

因为在32位的机器上一次访问32bit，也就是4个字节

若此时我们要访问int类型的变量，我们则需要访问两次，若对齐的话，我们只需要访问一次就能读取到i，减少了时间，更加的高效。

此时我们回到开头的例题

struct S1
{
	char c1;
	int i;
	char c2;
};

struct S2
{
	char c1;
	char c2;
	int i;
};


int main(void)
{
	printf("sizeof(struct S1) = %d\n", sizeof(struct S1));
	printf("sizeof(struct S2) = %d\n", sizeof(struct S2));

	return 0;
}

 

两个结构体是相同的，但因为结构体成员排列顺序的不同，导致占用的空间不同

所以我们可以让占⽤空间⼩的成员尽量集中在⼀起，来达到节省空间的目的

修改默认对齐数

#pragma这个预处理指令，可以改变编译器的默认对⻬数。

具体使用方法如下：

#pragma pack(4)

这样我们就可以把默认对齐数改成4

若我们需要把默认对齐数改回来，则可以用

#pragma pack()

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

结构体地址传参比结构体直接传参会更好一些，官方解释表示：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。 如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。

同时直接传参时，你做的任何操作都不会对原函数造成影响，因为在出函数的时候，临时变量就已经被销毁，而传地址则不会有影响

本篇内容较长，制作不易，点个免费的赞再走吧

下一节给大家带来位段的相关知识，谢谢观看