自定义类型：结构体、枚举、联合

结构体

  在之前的博客中有谈到过结构体的一些简单用法，现在我们先回顾一下结构体的简单知识点，再接着来聊聊结构体的更深层次的用法。

结构体声明

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct test
{
  int a;
  char b[1024];
}Test;
int main()
{
  Test test;
  test.a = 10;
  strcpy(test.b, "Main");
  printf("%d, %s\n", test.a, test.b);
  return 0;  
}

  上面的代码中，如果不使用typedef的话，那么在创建结构体变量的时候，就需要再结构体名之前加上struct，否则会报错。

匿名结构体

  有一种较为特殊的结构体，这种结构体没有名称，因此它在声明结束后无法再次定义变量，只能一次性使用，我们称这种结构体为匿名结构体。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct
{
  int a;
}test;
int main()
{
  test.a = 10;          
  printf("%d\n",test.a);
  return 0;
}

结构体的自引用

  c 语言中要求, 结构体内部不能包含自己这种结构体类型的成员，为什么呢？

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

  想象一下, 如果计算sizeof(Node)，那么结果会是多少呢？可能会无限递归的求下去，最终程序崩溃。正确的自引用方式：

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

  不过需要注意的是：

typedef struct
{
 int data;
 Node* next;
}Node;
//上面这样写代码是不可以的，不能用 typedef 重命名的类型名来自引用

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

结构体内存对齐

  这个知识点是一个非常重要的内容，今后找工作中会被面试官问到，所以一定要掌握。我们之前计算结构体大小都是将结构体各成员变量大小之和相加就得出了结构体的总大小，但是我们看接下来这个例子。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct test
{
  char c1;
  short a;
  char c2;                      
}Test;
int main()
{
  Test test;
  //以无符号长整型输出
  printf("%lu\n", sizeof(test));
  return 0;
}

//结果：6

从以上这个例子可以看出这个结构体占了 6 个字节，但是所有结构体成员加起来应该就是 4 个字节啊，这是为什么呢？其实结构体大小的计算与内存对齐有着很大的关系，以下是内存对齐的基本规则：

1.第一个成员在与结构体变量偏移量为 0 的地址处。
2.其他成员变量要对齐到某个数字 ( 对齐数) 的整数倍的地址处。
3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

  接下来我们用以上的规则来计算一下刚才这个结构体的总大小。
  首先char类型放在与结构体起始位置偏移地址为 0 的地方，占一个字节。short的大小为 2，我的环境是 vs 所以默认对齐数为 8，short小于它所以short对齐为 2，于是要放在偏移地址为 2的整数倍的地方，于是舍弃一个字节，放在偏移地址为 2 的地方，占两个字节，此时的总大小为 1 + 1（补齐）+ 2 = 4。之后还要再放一个char同理得对齐数为 1，放在任意地址处即可，于是放在偏移地址为5的地方，占一个字节。
  由此所有变量都放完了，但是根据规则中第三条我们还要让总大小为最大对齐数的整数倍，在这个结构体中最大对齐数为short的对齐数，为2，于是此时末尾还要再补齐一个字节，于是总大小为1 + 1（补齐）+ 2 + 1（补齐） = 6。由此这个结构体的大小才算是真正得出。

为什么会有这样的规定：

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

  那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到？下面有两个例子来进行对比：

typedef struct test
{
  char c1;
  int a;
  char c2;
}Test;
Test test;                    
printf("%lu\n", sizeof(test));
//结果:12=1+3(补齐)+4+1+3（补齐）

typedef struct test
{
  char c1;
  char c2;                      
  int a;
}Test;
Test test;
printf("%lu\n", sizeof(test));
//结果：8=1+1+2（补齐）+4

  从以上这个例子可以看出相同的成员变量就连不同的声明顺序也会导致结构体大小的不同。所以在定义结构体变量时，让占用空间小的成员尽量集中在一起，这样就可以既满足对齐，又节省空间。
  修改默认对齐数：在之前我们谈到函数声明时，用头文件进行包含会更方便，为了防止头文件重复包含，就使用到了#pragma这个预处理指令；在这里也可以使用这个预处理指令，在使用默认对齐数时，结构在对齐方式不合适，那么我们就可以自己更改默认对齐数。

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

#pragma pack(1)//设置默认对齐数为1
struct S2
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
    //输出的结果是什么？
    printf("%d\n", sizeof(struct S1));//结果：12
    printf("%d\n", sizeof(struct S2));//结果：6
    return 0;
}

位段

什么是位段

1. 位段的成员可以是int，unsigned int，signed int或者是char（属于整形家族）类型；
2. 位段的成员名后边有一个冒号和一个数字；

struct A
{
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
};

位段的内存分配

1. 位段的成员可以是int，unsigned int，signed int或者是char（属于整形家族）类型
2. 位段的空间上是按照需要以 4 个字节int或者 1 个字节char的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

//一个例子
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;

  下面我来画出它的空间是如何开辟的：

位段的跨平台问题

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

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

枚举

  枚举类型是一种类似于用宏定义常量的自定义类型。枚举顾名思义就是一一列举，把可能的取值一一列举。枚举定义与结构体的声明十分类似，不过我们要谨记中间的每个常量要用,隔开：

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

enum Color//颜色
{
 RED,
 GREEN=2,
 BLUE,
 BLACK=5
};

//RED=0,GREEN=2,BLUE=3,BLACK=5

  我们还可以用枚举类型定义变量，这样定义的变量的值就必须是枚举常量中出现的常量。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
enum Sex
{
  MALE,
  FEMALE,
  UNKNOWN,
};
int main()
{
  enum Sex sex = MALE;
  printf("sex = %d\n", sex);
  return 0;
}

//sex=0；

枚举的优点：

1.增加代码的可读性和可维护性
2.和 #define定义的标识符比较枚举有类型检查，更加严谨。 　
3.防止了命名污染（封装）
4.便于调试
5.使用方便，一次可以定义多个常量

联合体（共用体）

联合体是什么

  联合体是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间，所以也把联合体称为共用体；所以这样一个联合体变量的大小，至少是最大成员的大小（因为联合体至少得有能力保存最大的那个成员）。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
union Un
{
  char c;
  int i;
};
int main()
{
  union Un un;
  printf("%lu\n",sizeof(un));
  un.i = 4;
  un.c = 'a';
  printf("%d\n", un.i);     
  return 0; 
}

//结果：4   97

  从上面这个例子看出，联合体在空间上确实是共用同一块内存，当我们同时给两个成员变量赋值时另一个成员变量会扰乱其他成员变量的赋值。

联合体大小的计算：

1. 联合的大小至少是最大成员的大小。
2. 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

union Un
{
 char c[3];
 int i;
};
union Un1
{
 char c[5];
 int i;
};
union Un2
{
 short c[7];
 int i;
};
printf("%d\n", sizeof(union Un));  //4
printf("%d\n", sizeof(union Un1));//8
printf("%d\n", sizeof(union Un2));//16

联合体的应用

  相信大家一定见过这样一串数字 IP：117.136.50.133，这代表的是我们的 IP 地址；IP 地址（Internet Protocol Address）是指互联网协议地址，又译为网际协议地址。IP 地址是 IP 协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。这个我们后面会重点学习到，那么打印这样格式的一串数字，是不是要用到什么复杂的函数呢？其实是不需要的，只要使用联合体就可以很轻松的解决这个问题：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

union Ip
{
  int a;
  struct
  {
    char d1;
    char d2;
    char d3;
    char d4;
  };
};
int main()
{
  union Ip ip;
  ip.a = 0x11223344;
  printf("%d.%d.%d.%d\n", ip.d1,ip.d2,ip.d3,ip.d4);
  return 0;
}

//44.33.22.11

---

博客园发表于 2020-11-20 14:37