在前期我讲解过一次初始结构体，今天我们仔细讲解自定义类型：

初始结构体链接：

s7——结构体_c语言实现s7协议_wangjiushun的博客-CSDN博客

类型：内置类型和自定义类型

内置类型：语言自身定义的类型，如:char short int……

自定义类型(聚合类型)：结构体，枚举，联合

为什么要有自定义类型？

答:生活中有些(复杂)对象要被描述的话，不能简单使用单个内置类型。

如：

学生：名字+年龄+性别+成绩

书：书名+定价+书号等

结构成员用{}聚合在一起，所以也可叫聚合类型。

结构体

1. 结构体的声明

1.1 结构体的基础知识

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

回顾：成员变量的类型-->结构成员可以是变量、数组、指针，甚至是其他结构体。

vs数组：数组也是一些值的集合，但是这些值的类型是相同的。

1.2 结构的声明

struct tag//①struct结构体关键字，②tag结构体标签名(见明知意)

{

member-list;//成员列表1~N

}variable-list;//变量列表1~N

例如：声明一个学生类型

//定义学生:名字+年龄
//在C语言中：结构体类型是struct+tag，
//在C++中可以直接用tag表示
//不使用typedef
struct stu
{
  char name[20];
  int age;
}s1,s2;//声明类型的同时定义变量，s1,s2两个结构体变量是全局变量
//使用typedef
typedef struct stu
{
  char name[20];
  int age;
}stu;//stu不是结构体变量，是结构体类型的别名

注意：结构体使用typedef重命名只能在结构体声明时或声明后，不能在结构体之前重命名(报错:无法解析的外部命令，因为代码是由上到下依次执行的)。

1.3 特殊的声明(使用场景少)

在声明结构的时候，可以不完全的声明

匿名结构体：结构在声明的时候省略掉结构体标签(tag)。

注意：只能在声明时使用一次(即只能在声明的同时定义结构体变量，不能在其他地方再使用该结构体创建变量)。

//特殊的声明：
//匿名结构体(不完全声明)：在结构声明的时候省略掉结构体标签(tag)
struct
{
  int a;
  char b;
  float c;
}x;
struct
{
  int a;
  char b;
  float c;
} * p;
int main()
{
  p = &x;//合法吗？
  //答：非法的。
  //警告：虽然两个结构体成员是一样的，但是编译器会把上面两个声明当成两个完全不同的类型
  //匿名结构体只能使用一次，且是在声明时，该语句相当于又使用一次结构体
  return 0;
}

1.4 结构的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

代码1：
//结构的自引用
//在结构中包含一个类型为该结构本身的成员是否可以呢？
//代码1
struct Node
{
  int data;
  struct Node next;
};

思考：代码1可以吗；如果可以，那sizeof(struct Node)是多少？

答：①代码1不可以实现结构的自引用，因为在一个结构体还没有完全定义之前调用该结构体了，C是自上而下编译的，走到struct Node next；这一句的时候，编译器发现struct Node结构并没有定义完整，所以报错。

②如果可以，sizeof(struct Node)=4+4+4+……死递归下去，大小就是无限大。

代码2：正确的结构自引用

正确的结构自引用：定义成结构体的指针，结构的指针不受结构的内容影响，它只是一个指针，指向你定义的一个结构，至于这个结构完不完整是什么，它都不需要知道。因此编译器能令其通过。

结构体自引用其实就是数据结构中的链表，

如下图，了解即可，后期会详细讲解。

//正确的自引用方式
//代码2
struct Node
{
  int data;
  struct Node* next;
};

代码3：使用typedef:重命名的别名自引用可以吗

//使用typedef
//代码3
typedef struct Node
{
  int data;
  Node* next;//这样写可以，可行吗？
  //答：不可以，报错，编译器找到一个意外标识符，请确保标识符在使用前声明
  //在结构体自引用时，不能使用结构体的别名，因为代码是由上到下依次执行的
}Node;//结构体类型的别名

代码4：使用typedef时的正确做法

//解决方案
//代码4
typedef struct Node
{
  int data;
  struct Node* next;//结构体的自引用，使用结构体的本名
};

1.5 结构体变量的定义和初始化

①变量的定义：通过类型创建变量；

②变量的初始化：定义变量的同时赋初值

代码示例：

//结构体变量的定义和初始化
struct P
{
  int x;
  char ch;
}p1 = { 2, 'a'};//方式①：声明类型的同时定义结构体变量p1(全局的),并初始化
struct P p3 = { 3,'b' };//方式②：定义结构体变量p3(全局的)，并初始化
struct S
{
  double d;
  struct P p2;//结构体嵌套
  float f;
};
int main()
{
  struct S s = { 3.2,{4,'c'},6.2f };//方式③：定义结构体变量s(局部的)，并初始化
  struct S s1 = { .f = 3.1f,.p2.ch = 'd',.p2.x = 6,.d = 9.1 };//乱序初始化
  return 0;
}

1.6 结构体内存对齐

通过前面知识点，我们已经掌握了结构体的基本使用。

现在我们深入讨论一个问题：计算结构体的大小。

这是一个热门的考点：结构体内存对齐。

考点：

如何计算？

首先得掌握结构体的对齐规则：

1.结构体的第一个成员，对齐到结构体变量在内存中存放位置的0偏移处。

2.从第二个成员开始，每个成员变量都要对齐到(一个对齐数)的整数倍处。

①对齐数=编译器默认的一个对齐数与结构体成员自身大小的较小值。

②VS:默认对齐数为8；

Linux gcc：没有默认对齐数，对齐数就是结构体成员自身大小。

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

4.如果嵌套结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

练习：

案例1：

/结构体内存对齐
//计算结构体内存的大小
//案例1：结构体成员个数、类型一样，改变其成员顺序，结构体大小怎么样？
#include<stdio.h>
struct S1
{
  char ch1;
  int i;
  char ch2;
};
struct S2
{
  char ch1;
  char ch2;
  int i;
};
int main()
{
  printf("%d\n", sizeof(struct S1));//12
  printf("%d\n", sizeof(struct S2));//8
  return 0;
}

图解：

①struct S1

②struct S2

案例2：

//案例2
#include<stdio.h>
struct S3
{
  double d;
  char ch;
  int i;
};
int main()
{
  printf("%d\n", sizeof(struct S3));//16
  return 0;
}

图解：

案例3：结构体嵌套问题

//案例3：结构体嵌套问题
#include<stdio.h>
struct S3
{
  double d;
  char ch;
  int i;
};
struct S4
{
  char ch1;
  struct S3 s3;
  double d;
};
int main()
{
  printf("%d\n", sizeof(struct S4));//32
  return 0;
}

图解：

通过这些案例我们知道了计算，但是为什么存在内存对齐呢？

大部分的参考资料都是这么说的：

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

不是所有的硬件平台都能访问任意地址上的任意数据；某些硬件平台只能在某些地址处取某些特定的数据，否则抛出硬件异常(例：int-->对齐到4的整数倍)

2.性能原因

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅要一次访问。

图释：

总体来说：

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

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

答：让占用空间小的成员尽量集中在一起。

例如：

struct S1
{
  char c1;
  int i;
  char c2;
};
struct S2
{
  char c1;
  char c2;
  int i;
};
#include <stdio.h>
int main()
{
  printf("%d\n", sizeof(struct S1));//12
  printf("%d\n", sizeof(struct S2));//8
  return 0;
}

s1和s2类型的成员虽然一模一样，但是s1和s2所占空间的大小有区别。

1.7 查看偏移量与修改默认对齐数

（1）offsetof

1.头文件：“stddef.h”

2.功能：

在msdn上，该宏被写作：

size_t offsetof(structName,memberName);

第一个参数是结构体的名字，第二个参数是结构体成员的名字。该宏返回结构体structName中成员memberName的偏移量。偏移量是size_t类型的。

（2）#pragma pack

程序编译器对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。

1.#pragma pack(n)来设定变量以n字节对齐方式。（n：可选参数；指定packing的数值，以字节为单位；缺省数值是8，合法的数值分别是1、2、4、8、16。调用pack时不指定参数，n将被设成默认值。）

2.#pragma pack () /*取消指定对齐，恢复缺省对齐,等价于#pragma pack(pop)*/

代码实例：

#include<stdio.h>
#include<stddef.h>
#pragma pack(1)//设置默认对齐数为1
struct S1
{
  char c1;
  int i;
  char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
  //查看偏移量
  printf("%d\n", offsetof(struct S1, c1));//0
  printf("%d\n", offsetof(struct S1, i));//1
  printf("%d\n", offsetof(struct S1, c2));//5
  //计算结构体的大小
  printf("%d\n", sizeof(struct S1));//6
  return 0;
}

图示：

结论：

结构在对齐方式不合适的时候，我们可以自己更改默认对齐数。

1.8 结构体传参

先看代码：

#include<stdio.h>
struct S
{
  int data[1000];
  int num;
};
//结构体传参
void print1(struct S s)
{
  printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
  printf("%d\n", ps->num);
}
int main()
{
  struct S s = { {1,2,3,4}, 1000 };
  print1(s); //传结构体
  print2(&s); //传地址
  return 0;
}

上面的print1和print2函数哪个好些？

答案是：首选print2函数

原因：

函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大,参数压栈的系统开销比较大，所以会导致性能的下降。

结论：

结构体传参的时候，最好传结构体的地址。

2. 位段

结构体讲完，我们就得讲讲结构体实现位段的能力。

2.1 什么是位段

位段的声明和结构是类似的，有两个不同：

1、位段的成员必须是int，unsigned int或signed int类型。（大量测试，char类型也可以；但是成员的类型通常为相同类型）

2、位段的成员名后边有一个冒号和一个数字。（①位段 - 位：二进制位，②且冒号后面的数字不能大于开辟类型的大小）

例如：

//位段 - 位 ：二进制位
struct A
{
  int _a : 2;
  int _b : 5;
  int _c : 10;
  int _d : 30;
};
#include<stdio.h>
int main()
{
  //位段式的结构体A的大小是多少？
  printf("%d\n", sizeof(struct A));
  return 0;
}

答：A的大小为8个字节，为什么呢？

2.2 位段的内存分配

1、位段的成员可以是int，unsigned int，signed int或者是char（属于整形家族）类型

2、位段的空间上是按照需要以4个字节(int)或者1个字节（char）的方式来开辟的（用多少开辟多少，不够再开辟）

3、位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

图释结构A的大小为什么是8：

再来一个例子：

struct S
{
  char a : 3;
  char b : 4;
  char c : 5;
  char d : 4;
};
#include<stdio.h>
int main()
{
  //s在空间是如何开辟的？
  struct S s = { 0 };//将s初始化为0便于观察值的变化
  s.a = 10;
  s.b = 12;
  s.c = 3;
  s.d = 4;
  return 0;
}

图示：

2.3 位的跨平台问题

1、int位段被当成有符号还是无符号数是不确定的。

2、位段中最大数目不能确定（int在16位机器最大16,32位机器最大32，写成27，在16位机器会出问题）

3、位段中的成员在内存中从左向右分配，还是从右向左分配标准未定义。

4、当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结：

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

2.4 位段的应用

数据的传输，在数据的传输中我们要将其封装成数据包，如图：

我们看到有许多部分组成，如果我们不使用位段数据包就较大，网络传输就慢，如果使用位段节省空间数据包小，传输就快了。

3. 枚举

枚举顾名思义就是一一列举。

把可能的取值一一列举。

如我们生活中：

一周的星期一到星期日是有限的7天，可以一一列举。

性别有：男、女、保密，也可以一一列举

月份有12个月，也可以一一列举

这就可以使用枚举。

3.1 枚举类型的定义

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，当然在定义的时候也可以赋初值。

例如：

#include<stdio.h>
enum Sex//性别
{
  //枚举类型的可能取值——枚举常量
  //默认从0开始，一次递增1
  MALE,//0
  FEMALE,//1
  SECRET//2
};
enum Color//颜色
{
  //枚举常量，在定义是可以赋初值
  RED = 1,
  GREEN,
  BLUE = 5
};
int main()
{
  //打印性别的枚举常量
  printf("%d %d %d\n", MALE, FEMALE, SECRET);
  //打印颜色的枚举常量
  printf("%d %d %d\n", RED, GREEN, BLUE);
  return 0;
}

运行结果：

3.2 枚举的优点

为什么使用枚举？

我们可以使用#define定义常量，为什么要使用枚举？

枚举的优点：

1、增加代码的可读性和可维护性（如我们以前实现的通讯录，选择语句是使用的1,2,3等字面常量，那现在我们可以使用枚举来定义枚举常量实现见名知意）

2、和#define定义的标识符比较枚举有类型检查，更加严谨

3、防止命名污染（封装）

4、便于调试（#define在预编译时就已经被替换了）

5、使用方便，一次可以定义多个常量

3.3 枚举的使用

enum Color//颜色
{
  RED = 1,
  GREEN = 2,
  BLUE = 4
};
int main()
{
  enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
  clr = 5;  //ok??,在VS中虽然不报错，但是是不严谨的，在C++中直接报错
  return 0;
}

tip：枚举类型的大小与int一样

4. 联合（共用体）

4.1 联合类型的定义

联合也是一种特殊的自定义类型

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

例如：

#include<stdio.h>
//联合类型的声明
union Un
{
  char c;
  int i;
};
int main()
{
  //联合变量的定义
  union Un un;
  //打印联合变量的大小
  printf("%d\n", sizeof(un));
  //打印联合变量的起始地址
  printf("%p\n", &un);
  //打印联合成员c的起始地址
  printf("%p\n", &un.c);
  //打印联合成员i的起始地址
  printf("%p\n", &un.i);
  return 0;
}

运行结果：

图示：

4.2 联合的特点

1、联合的成员是共用同一块空间的，这样一个联合变量的大小；至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

2、理解：一般联合一次只能使用一个成员不能几个成员共同使用，就像超市的存物柜。

比如：

union Un
{
  int i;
  char c;
};
#include<stdio.h>
int main()
{
  union Un un;
  //下面输出的结果是什么？
  un.i = 0x11223344;
  un.c = 0x55;
  printf("%x\n", un.i);
  return 0;
}

运行结果：

为什么呢？

因为联合的成员是共用同一块空间的，已经使用了联合成员i赋值11223344，又使用联合成员c赋值55，所以44被55覆盖。（注意：同时使用联合成员并不是将前一个成员的存储空间销毁，而是将前一个成员共用空间的值覆盖；销毁是将存储空间还给操作系统。）

面试题：判断计算机的大小端存储（在之前数据的存储中我们使用指针的方式，现在使用联合方式）

int check_sys()
{
  union UN
  {
    char c;
    int i;
  }un;
  un.i = 1;
  //0x 00 00 00 01
  //低地址-------------高地址
  //01 00 00 00 - 小端（数据的低位放在低地址，高位放在高地址）
  //00 00 00 01 - 大端
  return un.c;//小端返回1，大端返回0
}
#include<stdio.h>
int main()
{
  if (check_sys())
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}

4.3 联合大小的计算

1、联合的大小至少是最大成员的大小

2、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍（对齐数=编译器默认对齐数与联合成员自身大小的较小值）

比如：

union Un1
{
  char c[5];
  int i;
};
union Un2
{
  short c[7];
  int i;
};
#include<stdio.h>
int main()
{
  //下面输出两个联合的大小
  printf("%d\n", sizeof(union Un1));//Un1最大成员大小为5，最大对齐数4——>联合大小8
  printf("%d\n", sizeof(union Un2));//Un2最大成员大小14，最大对齐数4——>联合大小16
  return 0;
}

自定义类型结构体使用场景多，枚举、联合较少，但是应该在平时多写代码多感悟。

自定义类型——结构体，枚举，联合

结构体

1. 结构体的声明

1.1 结构体的基础知识

1.2 结构的声明

1.3 特殊的声明(使用场景少)

1.4 结构的自引用

1.5 结构体变量的定义和初始化

1.6 结构体内存对齐

1.7 查看偏移量与修改默认对齐数

（1）offsetof

（2）#pragma pack

1.8 结构体传参

2. 位段

2.1 什么是位段

2.2 位段的内存分配

2.3 位的跨平台问题

2.4 位段的应用

3. 枚举

3.1 枚举类型的定义

3.2 枚举的优点

3.3 枚举的使用

4. 联合（共用体）

4.1 联合类型的定义

4.2 联合的特点

4.3 联合大小的计算

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

自定义类型——结构体，枚举，联合

结构体

1. 结构体的声明

1.1 结构体的基础知识

1.2 结构的声明

1.3 特殊的声明(使用场景少)

1.4 结构的自引用

1.5 结构体变量的定义和初始化

1.6 结构体内存对齐

1.7 查看偏移量与修改默认对齐数

（1）offsetof

（2）#pragma pack

1.8 结构体传参

2. 位段

2.1 什么是位段

2.2 位段的内存分配

2.3 位的跨平台问题

2.4 位段的应用

3. 枚举

3.1 枚举类型的定义

3.2 枚举的优点

3.3 枚举的使用

4. 联合（共用体）

4.1 联合类型的定义

4.2 联合的特点

4.3 联合大小的计算

热门文章

最新文章

相关电子书

相关实验场景