本教程视频已同步到B站： 程序员的C——实用编程，不玩虚的！

高级语法

结构体

背景

结构体是一种聚合数据类型，C语言的数组也是一种聚合数据类型，它们显著的区别是，数组是相同数据类型的集合，而结构体可以是不同数据类型的集合。

假如要表示一个学生，那么我们可能需要声明多个变量

// 姓名
char *name;
// 年龄
int age;
// 编号
char *number;
// 年级
char *grade;

这在实际操作中非常麻烦，我们需要一种新的数据类型，将这些信息存放在一起，而不是这样分散的去表示和操作。数组显然是无法满足这个需求的，因为数组只能存放相同的数据类型，一个学生的信息，可能需要多种数据类型来表示，比如考试成绩，这个就需要float类型来表示。

结构体的声明与使用

为了实现类似上述的这种需求，结构体就诞生了

// 声明一个结构体
struct student {
    char *name;
    int age;
    char *number;
    char *grade;
};

结构体声明的一般格式

struct 标签名 ｛
	成员变量1
	成员变量2
    ……
｝;

结构体被声明之后，就相当于产生了一个新的数据类型，我们可以如下使用：

#include <stdio.h>
// 声明一个结构体
struct student
{
    char *name;
    int age;
    char *number;
    char *grade;
};

int main(){
    // 声明结构体变量:stu
    struct student stu;
    // 为结构体中的成员赋值
    stu.name = "zhangsan";
    stu.age = 19;
    stu.number = "A010";
    stu.grade = "18级"; 
    // 访问结构体中各个成员变量的内容
    printf("学生信息：%s,%d,%s,%s\n",stu.name,stu.age,stu.number,stu.grade);
    return 0;
}

打印结果：

学生信息：zhangsan,19,A010,18级

有几个点需要注意：

1. 使用关键字struct + 标签名 + 一对花括号 + 分号 来声明结构体。在花括号中，声明结构体需要包含的变量，这些变量被称为结构体的成员变量，或成员字段。一定要注意，结尾的分号不能掉！
2. 在使用时，需将struct + 标签名合起来看做一种新的类型，然后使用我们熟知的数据类型 + 变量名的格式来声明一个结构体变量。例如struct student stu;，这里struct student是一种新类型，stu则是变量名。这里一定要注意，声明结构体和声明结构体变量完全是两回事！
3. 使用英文句号.来访问结构体中的成员变量，这被称为结构体成员访问符。

通过这个例子，我们可以直观感知到，结构体就如同分组一样，将一伙人分成一个小组，然后给这个组命名，以后就用这个组名来代表这一伙人。结构体的出现，可以使代码变得简洁，例如以前我们需要将一个学生的信息作为参数传入到一个函数中处理，那么我们就必须给这函数定义一系列形式参数，现在则只需要定义一个结构体参数就行了，这个好处就如同将各种小物件打包在一起，出门只需要推一个旅行箱一样方便。

// 结构体类型做函数参数
void printStudent(struct student s){
    printf("学生信息：%s,%d,%s,%s\n",s.name,s.age,s.number,s.grade);
}

int main(){
    struct student stu;
    stu.name = "zhangsan";
    stu.age = 19;
    stu.number = "A010";
    stu.grade = "18级";
    
    printStudent(stu);
    return 0;
}

结构体仅仅是构造了一种新的组合数据类型，其使用与普通的基本类型大致相同，它既可作为函数参数也可作为函数的返回值。

结构体变量的初始化

以上是通过结构体变量来访问成员变量来逐个进行赋值的，实际上结构体可以在声明的同时进行初始化，这点类似于数组。

按顺序初始化

struct student stu={"zhangsan",19,"A010","18级"};

按照声明结构体时的成员变量的顺序，在花括号中依次填入其值，如同数组初始化。

缺省的顺序初始化

与数组类似的，我们也可以进行缺省的初始化，如下，这样就只会对前两个成员变量赋值，后面省略的变量会被进行零值初始化。

struct student stu={"zhangsan",19};
printStudent(stu);

打印结果：

学生信息：zhangsan,19,(null),(null)

指针变量的零值就是NULL，可以看到省略的最后两个成员变量被赋了零值。

零值初始化

前面一直强调，局部变量应当先初始化再使用，当结构体变量做局部变量时，也应当遵循。以上代码示例是没有遵循的，通常人们都喜欢先声明，后面就直接去操作了，忽略了初始化步骤，特别是当我们不确定结构体成员变量的值时，就会先声明放在那，这是不好的习惯，我们应当先做零值初始化。

正确示范：

int main(){
    // 声明同时对所有成员变量做零值初始化
    struct student stu={NULL};

    // 初始化之后再去使用，正确！
    stu.name = "zhangsan";
    stu.age = 19;
    stu.number = "A010";
    // stu.grade = "18级";
    
    printStudent(stu);
    return 0;
}

错误示范：

int main(){
    // 声明但不初始化
    struct student stu;

    // 直接就去使用，但省略了对grade变量的赋值
    stu.name = "zhangsan";
    stu.age = 19;
    stu.number = "A010";
    // stu.grade = "18级";
    
    printStudent(stu);
    return 0;
}

以上代码异常退出，这是因为声明时未对结构体的所有成员进行零值初始化，在使用时，又没有对全部成员进行赋值，导致成员变量出现了野指针的情况。局部变量的特点是，声明但不初始化，那么它的值是随机的，如果是指针变量，那么它可能会指向一个随机的内存空间，这可能是一个不允许访问的内存空间，这就是所谓野指针。

除了可以使用NULL做零值初始化，也可以使用0，如下

struct student stu={0};

在GCC编译器中，甚至可以直接省略什么都不写，但不推荐，因为微软的VC编译器不支持，这样写的代码兼容性太差。

struct student stu={};

指定成员初始化

按顺序初始化是不够灵活的，而且还需要记忆结构体成员变量的顺序，当结构体成员变量比较多时，就有些糟心了。因此C99标准推出了新的语法，指定成员变量名进行初始化

    struct student stu={.age=18, .name="张三"};
    printStudent(stu);

在成员变量名前面加上一个成员访问符.，然后使用=号的形式进行初始化赋值，多个之间用逗号分隔。这种新的语法有两个明显的好处，一是语义化表达，每个值对应哪个成员变量非常清晰；第二是无序，不用再去关心成员变量声明时的顺序了。与顺序初始化相同的，没有被指定的成员变量，则会被自动的初始化为零值。

这种结构体初始化方式是我推荐的，它极大的提升了代码可读性，而且这种被称为声明式语法的表达，正是目前其他高级编程语言所流行的趋势。当我们掌握C语言再去学习Go语言时，会发现Go的结构体都是这样去初始化的。另外值得说明的是，这种语法虽然是C99的新特性，但是好东西，微软的VC编译器也是会支持的，在VS2013及以上版本，可以放心使用。你的VC6.0可以淘汰了！

结构体与内存

先看一个现象

struct A
{
    int a;
    char b;
    short c;
};

int main(){
    struct A struA={0};
    printf("size is %d\n",sizeof(struA));
    return 0;
}

打印结果：

siez is 8

我们将结构体成员变量声明的顺序调整一下，在次打印

struct A
{
    char b;
    int a;
    short c;
};

打印结果：

siez is 12

这里就发生了很奇怪的现象，第一次我们使用sizeof获取的结构体占用内存大小是8，当调整成员变量声明的顺序后，即将char b;和int a;顺序交换，其他都不变，结构体占用的内存大小增加了，变成了12，为什么会出现这样的情况呢？

有一些教材上说，结构体占用的内存大小就等于结构体各个成员变量占用的内存大小之和，这里char 1个字节，int4个字节，short2个字节，加起来是7字节，怎么跑出了8个字节呢？显然这种说法是存在问题的。要把这些问题全部搞清楚，就得了解结构体在内存中的分布情况。

首先我们得开动脑筋，学会该怎么去研究和分析问题，有时候一些资料自相矛盾时，我们感到迷糊时，都得自己想办法去探索和试验，所谓实践出真知，放到这里再合适不过了。

#include <stdio.h>

struct A
{
	int a;
	char b;
	short c;
};

int main(){
	struct A struA = {0};
	// 打印结构体的内存地址
	printf("A address is %x\n", &struA);
	// 分别打印结构体每个成员变量的内存地址
	printf("A.a address is %x\n", &struA.a);
	printf("A.b address is %x\n", &struA.b);
	printf("A.c address is %x\n", &struA.c);
	return 0;
}

观察打印结果：

A address is 46fd30
A.a address is 46fd30
A.b address is 46fd34
A.c address is 46fd36

我们观察到的第一个现象是，结构体变量的内存地址和它的第一个成员变量的地址是相同的。这一点和数组很相似，数组变量的地址与数组第一个元素的地址也是相同的。

第二个现象是，结构体在内存中的布局，是将它的所有成员变量，按照声明时的顺序连续排列到内存空间中。这个也很容易看出来，变量a、b、c的内存地址编号都是有顺序的，a是int类型，占用四个内存单元，它的起始地址是46fd30，紧随其后的b变量起始地址正好是46fd34

再看示例：

    // 设置有效值，查看内存分布情况
	struct A struA = {18,'a',127};
	printf("A address is %x\n", &struA);
	printf("A.a address is %x\n", &struA.a);
	printf("A.b address is %x\n", &struA.b);
	printf("A.c address is %x\n", &struA.c);

我们可以使用Visual Studio工具来查看真实内存分布图，为了便于理解，以下字节中的值都是用我们熟悉的十进制表示的

注意，这里-52是VC编译器将未使用的字节做自动填充时所用的十进制默认值，对应的也就是我们前面章节说的16进制数0xcc，它表示这个字节没有被使用。一定要搞清楚，0xcc的含义和0是不同的，如果这个字节的值是0，那么表示它是被使用的，只是它此刻的值就是0而已。

将结构体成员变量声明的顺序调整一下，再次查看内存布局

struct A
{
    char b;
    int a;
    short c;
};

struct A struA = { 'a', 18, 127 };

观察上图，很容易发现规律，char类型本来是一个字节，但是现在在结构体中却占了4个字节，int a紧随其后，接下来short c在结构体中又占了4个字节！

现代计算机中内存空间都是按照字节划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问， 这就需要各种类型数据按照一定的规则在空间上排列，而不是按顺序的一个接一个的排放，这就是内存对齐。

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。另一方面，CPU访问内存时，并不是逐个字节访问，比如32位的CPU，通常访问内存的单位是4字节，因此为了提升性能，需要做内存对齐。

以上就是C语言中，所谓的结构体内存对齐的概念。带给我们的启示就是，在声明结构体成员变量时，不要随意去排列成员变量的顺序，要有意识的去安排变量的顺序适应内存对齐，这样可以减少结构体占用的内存大小。

如下这种排列就是不合理的，导致编译器做内存对齐时，将其分成三组，每组4个字节，这使得该结构体占用的内存变成了12字节。而将int a放在第一个成员位置时，编译器内存对齐后，结构体仅占用8字节大小。这正解惑了我们一开始提出的疑问。

struct A
{
    char b;
    int a;
    short c;
};

有些善于发现问题的朋友可能会想到，在64位系统里，long类型表示8字节，那么结构体怎么进行内存对齐呢？实际上，上面仅仅是打比方来说明问题，不同的编译器，其结构体内存对齐的规则也不尽相同，并不是简单的仅仅按照4字节来对齐。Windows下的VC编译器，主要按照4字节或8字节来对齐，而Linux下的GCC则使用2字节或4字节来对齐，这个对齐参数被称为对齐模数。

如果我们不想优化性能，在某些特殊场景下，不希望某个结构体做内存对齐，则可以通过预编译指令进行设置

// 传入1，指定不做内存对齐，在结束处pack()不传参，恢复内存对齐
# pragma pack(1)
struct A
{
    char b;
    int a;
    short c;
};
# pragma pack()

int main(){
    struct A struA = { 0 };
	printf("size is %d\n",sizeof(struA));
    return 0;
}

用# pragma pack(1)和# pragma pack()将不希望内存对齐的结构体包裹起来，再次查看打印结果

size is 7

结构体与指针

结构体与数组很像，本质上就是指的一片特定的连续的内存空间，结构体成员就在这边内存空间中按顺序分布。那么所谓结构体指针，也就是指向该结构体的指针，结合结构体内存分布知识可知，这个指针实际上就是保存了结构体空间的初始地址。

int main(){
    // 声明并初始化一个结构体变量
    struct student stu = {0};
    // 声明一个结构体指针变量，并指向一个结构体
    struct student *p_stu = &stu;

    // 通过结构体指针访问成员
	printf("学生信息：%s,%d,%s,%s\n",p_stu->name,p_stu->age,p_stu->number,p_stu->grade);
    return 0;
}

事实上，将结构体作为一种新的类型，那么结构体指针与其他类型的指针用法也是相似的，唯一需要注意的地方是，结构体变量访问成员，使用成员访问符.，而结构体指针变量是不同的，它使用一个小箭头->来访问，要注意这两者的区别，万万不能混淆。

在C语言中，除了数组做函数参数是地址传递外，其他所有类型都是值传递，结构体也是如此。因而，在将结构体传入一个函数内部时，应当考虑使用结构体指针，避免对结构体做内存拷贝，用以提升性能。

结构体的其他声明方式

上面的结构体声明方式只是一般方式，除此之外，还有各种怪异的声明方式，大多数是不推荐的，但是要能看懂别人的代码。

声明结构体同时还声明结构体变量

int main(){
    // 声明结构体的同时，再声明两个结构体变量a、b
    struct student
    {
        int age;
        char *name;
        char *number;
        char *grade;
    }a,b;


    // 再声明一个结构体变量c
    struct student c = {0};
    return 0;
}

还可以在声明结构体并声明结构体变量的同时初始化

int main(){
    struct student
    {
        int age;
        char *name;
        char *number;
        char *grade;
    }a={0},b={.name="李四"};

    printf("%s",b.name);
    return 0;
}

声明匿名的结构体

声明结构体时的标签名是可以省略的

    // 声明一个结构体，并省略标签名，同时声明两个结构体变量a、b
    struct
    {
        int age;
        char *name;
        char *number;
        char *grade;
    }a,b;

匿名结构体与有名字的结构体有显著的区别，因为它没有名字，必须在声明的同时声明好需要的结构体变量，后面它是没法再去声明新的结构体变量的。这种用法有一个用处，如果我只指定声明一个结构体变量，那么全局就只有一个该结构体变量，后面无法定义新的结构体变量了。

结构体类型定义

在结构体的一般声明格式中，当我们声明好一个结构体后，使用的时候还需要将struct关键字+标签名作为一个整体来声明新的结构体变量，如struct student stu;，这样的语法表达非常麻烦。实际上在C语言中，结构体声明通常是和另一关键字typedef结合起来使用的。

// 使用typedef时，省略结构体标签名
typedef struct{
    int age;
    char *name;
    char *number;
    char *grade;
} Student;

typedef struct{
    int x;
    int y;
} Point;

int main(){
    // 声明结构体变量
    Student stu = {0};
    Point point = {10,20};
    return 0;
}

以上的结构体使用方式，才真正符合我们的编程直觉，看起来更像C++、Java中的类的使用。通常的，我们应该在头文件中用以上方式声明结构体，然后在源文件中包含头文件，使用相应的结构体。

拓展

typedef是一个可以用来定义类型别名的关键字，它并不仅仅是用在结构体声明中

typedef 旧类型名 新别名;

#define false 0
#define true 1
typedef int bool;
typedef char byte;

int main(){
    bool b=false;
    byte stream[10];
    return 0;
}

要注意，typedef定义的类型别名后面，一定要跟上分号结束。

内存对齐由来

16位CPU

32位CPU

1. CPU通过地址总线，找到该数据

2. 通过控制总线得知该操作是读操作还是写操作

3. 通过数据总线将该数据读取到CPU或者从CPU写到内存中

因此：

• 地址总线的宽度决定了CPU的寻址能力

• 数据总线的宽度决定了CPU单次数据传输量，也就是传输速度

• 控制总线决定了CPU对其他控件的控制能力以及控制方式

再看一个示例:

struct B {
    char  a;
    int b;
}

结构体内存对齐规则

• 第一个成员在结构体变量偏移量为0 的地址处
• 其他成员变量要对齐到某个数字（对齐模数）的整数倍的地址处
• 结构体总大小为最大对齐数的整数倍。（每个成员变量都有自己的对齐数）
• 如果嵌套结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（包含嵌套结构体的对齐数）的整数倍。

总的来说，硬件体系结构的内存对齐和不对齐，是在时间和空间上的一个权衡。内存对齐了，则是以空间换时间。

思考题：

以4为对齐模数，计算以下结构体的总内存大小

# pragma pack(4)

struct Mem
{
	char a[18];	      // 18 bytes
	double b;	      // 8 bytes	
	char c;		      // 1 bytes
	int d;		      // 4 bytes
	short e;	      // 2 bytes
};

结构体总结

1. 在声明结构体变量的时候，编译器就为其分配内存空间
2. 结构体在内存中的分布，是一片连续的内存空间
3. 结构体指针保存的是结构体在内存空间的起始地址
4. 结构体的总内存大小并不一定等于其全部成员变量内存大小之和，当存在内存对齐时，可能会多占用一些额外的空间
5. 结构体变量使用.访问成员，结构体指针使用->访问成员
6. 声明结构体时，建议结合typedef关键字创建别名
7. 结构体可以嵌套使用，即将一个结构体作为另一个结构体的成员

枚举

枚举是 C 语言中的一种基本数据类型，它可以让数据更简洁，更易读。它的底层实际上是一个整数。语法格式如下：

enum　枚举名　{枚举元素1,枚举元素2,……};

enum Week
{
      MON, TUE, WED, THU, FRI, SAT, SUN
};

注意，第一个枚举成员的默认值为整型 0，后续枚举成员的值在前一个成员上递增1。当然，我们也可以显式指定枚举值。

enum Week
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

其效果，类似于以下宏定义，但不建议使用宏。

#define MON  1
#define TUE  2
#define WED  3
#define THU  4
#define FRI  5
#define SAT  6
#define SUN  7

声明枚举变量与结构体类似，使用enum Week day;，要简化变量声明，亦可使用typedef关键字。

关注公众号：编程之路从0到1