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

结构体

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

结构体的声明

struct tag //结构体类型名
{
    member-list; //成员列表
}variable-list; //变量列表

例如描述一个学生：

struct Stu
{
   char name[20];
   int age;
   char sex[5];
   char id[20];
}; //注意分号不能丢

结构体的自引用

结构体中可以包含该结构体本身吗？答案是可以的。
正确的自引用方式：

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

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

定义变量：

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}; //结构体嵌套初始化

结构体成员的访问

结构体的成员可以是标量、数组、指针，甚至是其他结构体。
结构体变量访问成员是通过点操作符访问的，如果结构体变量是指针变量，则通过 ” -> ” 操作符来访问。例如：

可以看到s有成员name和age，访问成员：

//点操作符访问成员
struct Stu s；
strcpy(s.name,"zhangsan"); //使用.访问name成员
s.age = 20; //使用.访问age成员

//->操作符访问成员
struct Stu *p；
strcpy(p->name,"lisi"); //使用->访问name成员
p->age = 20; //使用->访问age成员

结构体内存对齐

我们先来看几道练习题：

//练习1
struct s1
{
   char c1;
   int i;
   char c2;
};
printf("%d\n",sizeof(struct s1));

程序的输出结果是12。
分析一下：

//练习2
struct s2
{
   double d；//对齐数为8
   char c；//对齐数为1
   int i；//对齐数为4
}；
printf("%d\n",sizeof(struct s2));

程序的输出结果为16。分析过程同上。

//练习3-结构体嵌套问题
struct s3
{
   char c1；//对齐数为1
   struct s2;//对齐数为8 因为s2中最大对齐数是8
   double d;//对齐数是8
}；
printf("%d\n",sizeof(struct s3));

程序的输出结果为32。分析过程同上。
结构体对齐原因

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

结构体内存对齐规则

• 第一个成员在与结构体变量偏移量为0的地址处。

• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
  对齐数 = 编译器默认的一个对齐数与该成员大小的较小值（VS中为8，Linux中为4）

• 结构体总大小为最大对齐数的的整数倍。

• 如果嵌套了结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

修改默认对齐数

我们可以通过#pragma这个预处理指令，来改变我们的默认对齐数。
如：

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

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

结构体传参

有如下代码：

#include <stdio.h>
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;
}

在上述的代码中，一个是传结构体，一个是传结构体地址，使用时应首选print2函数。
原因：函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
结构体在传参的时候，要传结构体的地址。

位段

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

struct A
{
   int _a:2; //给_a分配2位
   int _b:5; //给_b分配5位
   int _c:10; //给_c分配10位
   int _d:30; //给_d分配30位
};

A就是一个位段类型。那么位段A的大小是多少呢 ？答案是8字节。
分析一下：

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

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

---

枚举

枚举顾名思义就是一一列举，把可能的取值一一列举。比如我们现实生活中：

一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举。
枚举类型的定义
如：

enum Day //星期
{
   Mon,
   Tues,
   Wed,
   Thur,
   Fri,
   Sat,
   Sun
};

enum Sex //性别
{
   MALE,
   FAMALE,
   SECRET
};

以上定义的都是枚举类型，{}中的内容是枚举类型的可能取值，也叫枚举常量。这些可能取值都是有值得，默认从0开始一次递增1，当然在定义的时候也可以赋初值。如：

enum Sex //性别
{
   MALE=1，
   FAMALE=2,
   SECRET=4
};

枚举的优点

• 增加代码的可读性和可维护性
• 和#define定义的标识符比较枚举有类型检查，更加严谨
• 防止了命名污染
• 便与调试
• 使用方便，一次可以定义多个常量

可以利用枚举类型实现一个状态机来完成C注释到C++注释的转换。

---

联合（共用体）

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

//联合类型的声明
union Un
{
   char c;
   int i;
};
//联合类型的定义
union Un un;
//计算联合的大小
printf("%d\n",sizeof(union Un));

程序的输出结果为4。分析一下：

联合大小的计算

• 联合的大小至少是最大成员的大小。
• 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
  例如：

union Un1
{
  char c[5]; //对齐数为1，大小为5
  int i; //对齐数为4，大小为4
};
//Un1的大小为8，因为最大成员大小为5，不是最大对齐数的整数倍，要对齐，所以为8

union Un2
{
   short c[7]; //对齐数为2，大小为14
   int i; //对齐数为4，大小为4
};
//Un2的大小为16，因为最大成员大小为14，不是最大对齐数的整数倍，要对齐，所以为16

大小端问题

判断当前计算机的大小端存储。
大端：大端字节序存储，是指数据的低位保存在内存的高地址中，数据的高位保存在内存的低地址中。
小端：小端字节序存储，是指数据的低位保存在内存的低地址中，数据的高位保存在内存的高地址中。
根据联合的优点，可写出代码如下：

#include 

int check_sys()
{
    union Un
    {
        char c;
        int i;
    }un;
    un.i = 1;
    return un.c;
}

int main()
{
    int ret = 0;
    ret = check_sys();
    if(ret == 1)
        printf("小端\n");
    else
        printf("大端\n");
    return 0;
}

联合和结构体巧妙使用

将long类型的IP地址，转换为点分十进制的表示形式。
代码如下：

#include 

union ip_addr
{
    unsigned long addr;
    struct 
    {
        unsigned char c1;
        unsigned char c2;
        unsigned char c3;
        unsigned char c4;
    }ip;
};

int main()
{
    union ip_addr my_ip;
    my_ip.addr = 19216801;
    printf("%d.%d.%d.%d\n",my_ip.ip.c1,my_ip.ip.c2,my_ip.ip.c3,my_ip.ip.c4);
    return 0;
}

---

以上内容均为学习过程中的总结，如有不足之处，请指正。