我们知道c语言基本数据类型有：

本篇将重点介绍C语言中的自定义类型：结构体、枚举、联合

结构体

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

• 构造：
  struct 结构体名
{
结构体所包含的变量或数组
};

• 声明与定义

struct Stu
{
    char name[20];//名字
    int age;//年龄
    char sex[5];//性别
    char id[20];//学号
}；
int main()
{
    struct Stu s;
    return 0;
}

代码含义：

• struct Stu 是结构体类型，相当于int、float，不申请空间。Stu 是结构体标签。

• struct Stu s通过类型创建变量，申请空间（实例化）。
  

• 不完全声明（匿名结构体类型）

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
struct
{
    int a;
    char b;
    float c;
}x;
struct
{
    int a;
    char b;
    float c;
}*p;
int main()
{
    p = &x;
    system("pause");
    return 0;
}

上面的代码执行后发现是有bug的！

这是因为编辑器会把上面两个声明当成完全不同的两个类型。
正确代码：

struct 
{
    int a;
    char b;
    float c;
}x,*p;
int main()
{
    p = &x;
    system("pause");
    return 0;
}

• 结构体的访问
  
  • 结构体变量访问成员
    结构变量的成员是通过定操作符（.）访问的。点操作符接受两个操作数

struct S s; 
strcpy(s.name, "zhangsan");// ?使用.访问name成员
s.age = 20;//使用.访问age成员

• 结构体访问指向变量的成员
  有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。

struct S 
{    
    char name[20];  
    int age;  
}s;
void print(struct S* ps) 
{    
    printf("name = %s   age = %d\n", (*ps).name, (*ps).age); 
    printf("name = %s   age = %d\n", ps->name, ps->age);                
}

• 结构体的自引用

struct Node 
{    
    int data;    
    struct Node* next; //指向同类型数据的指针
};

• 结构体的不完整声明

struct B; //不完整声明
struct A 
{    
    int _a;    
    struct B* pb; 
}; 
struct B 
{    
    int _b;    
    struct A* pa; 
};

• 结构体的内存对齐

  • 为什么存在内存对齐

    1.平台原因（移植原因）
    不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定的数据，否则抛出硬件异常。

    2.性能原因
    数据结构（尤其是栈）应该尽可能地在自然边界上对齐。
    原因在于，为了访问未对齐的内存，处理器需要两次内存访问；而对其的内存访问仅需要一次访问。

  • 结构体对齐原则
    1.第一个成员在与结构体变量偏移量为0 的地址处。
    2.其他成员变量要对齐放到某个数字（对齐数）的整数倍的地址处。对齐数=编译器默认的一个对齐数与该成员大小的较小值。
    VS中默认的值是8，Linux中默认的值是4。
    3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
    4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

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

struct S1
{
    char c1;
    int i;
    char c2;
}
printf("%s\n",sizeof(struct S1));//1+3+4+1+3=12

struct S2 
{    
    char c1;    
    int i; 
}; 
printf("%d\n", sizeof(struct S2));//1+1+2+4=8
struct S3 
{    
    double d;    
    char c;
    int i; 
}; 
printf("%d\n", sizeof(struct S3));//8+1+3+4=16

struct S4 
{    
    char c1;
    struct S3 s3;
    double d;
}
printf("%d\n", sizeof(struct S4));//1+7+16+8=32

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

struct S
{
    char c1;
    int i;
    char c2;
}
void print(struct S *ps)
{

    ...
}
int main()
{
    print（&s）;
    return 0;
}

位段

• 与结构体不同的是：

  • 位段的成员必须是 int、unsigned int、int 或signed int 、char（属于整型家族类型）

  • 位段的成员名后边有一个冒号和一个数字

• 位段的分配内存
  
  • 位段的空间是按照需要以1个字节（char）或4个字节（int）的方式来开辟的
  • 位段涉及很多不确定因素，位段是不跨平台的，注重可移植性的程序应该避免使用位段

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;

printf("%d\n",sizeeof(struct S));//3

• 位段的跨平台问题

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

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

枚举

• 定义：顾名思义就是把可能的取值一一列举
• 构造：

enum 枚举名{
标识符[=整型常数],
标识符[=整型常数],
...
标识符[=整型常数]
} 枚举变量;

如果枚举没有初始化, 即省掉”=整型常数”时, 则从第一个标识符开始, 顺

次赋给标识符0, 1, 2, …。但当枚举中的某个成员赋值后, 其后的成员按依次

加1的规则确定其值。

• 声明与定义

enum Color
{
    RED=1,
    GREEN=2;
    BLUE=4;
};
enum Color clr = GREEN;

• enum Color是枚举类型

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

• 注意:

  1. 枚举中每个成员(标识符)结束符是”,”, 不是”;”, 最后一个成员可省略”,”。

  2. 初始化时可以赋负数, 以后的标识符仍依次加1。

  3. 枚举变量只能取枚举说明结构中的某个标识符常量。

• 枚举优点

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

联合（共用体）

• 定义： 在进行某些算法的C语言编程的时候，需要使几种不同类型的变量存放到同一段内存单元中。这种几个不同的变量共同占用一段内存的结构，在C语言中，被称作”共用体”类型结构，简称共用体。
• 构造：

union 共用体名
{
成员表列
}变量表列;

• 声明与定义

我们用一段代码说明，用结构体判断编译器的大小端（面试题）

int check_sys()
{
    union Un
    {
        int i;
        char c;
    }un;
    un.i=1;
    return un.c ;
}
int main()
{
    if(check_sys()==1)
        printf("小端\n");
    else
        printf("大端\n");
        return 0

• 联合的特点

  • 同一个内存段可以用来存放几种不同类型的成员，但是在每一瞬间只能存放其中的一种，而不是同时存放几种。换句话说，每一瞬间只有一个成员起作用，其他的成员不起作用，即不是同时都在存在和起作用。

  • 共用体变量中起作用的成员是最后一次存放的成员，在存入一个新成员后，原有成员就失去作用。

  • 共用体变量的地址和它的各成员的地址都是同一地址。

  • 不能对共用体变量名赋值，也不能企图引用变量名来得到一个值。

  • 共用体类型可以出现在结构体类型的定义中，也可以定义共用体数组。反之，结构体也可以出现在共用体类型的定义中，数组也可以作为共用体的成员。

  • 共用体变量也可以作为函数的参数和返回值

• 联合大小的计算

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

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

结构体和共同体的结合使用

我们网络的IP地址是long类型的一段数字，如： 19237271，但是为了方便读写，我们写成点分十进制形式:192.37.27.1
那么我们怎么转换呢？

union ip_add
{
    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=19237271;
    printf("%d.%d.%d.%d\n",my_ip.ip.c4,my_ip.ip.c3,my_ip.ip.c2,my_ip.ip.c1);
    return 0;
}

cs