自定义类型

结构体

结构体的声明

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

//tag 结构体标签

例如

struct STu
{
    char name[20];  //名字
    int age;  //年龄
    char sex[5];  //性别
    char id[20];  //学号
};

特殊的声明

//匿名结构体类型
struct  //省略结构体标签
{
    int a;
    char b;
    float c;
}x; //若不创建x，则无法使用该结构体

结构体的不完全声明

struct B; //不完全声明
struct A
{
    int a;
    struct B *p;
};
struct B
{
    int B;
    struct A *p;
};

结构体的成员

结构体的成员可以是标量，数组，指针，甚至是其他结构体

结构体成员的访问

在这里，我们声明一个结构体

struct S
{
    int a;
    char b;
    float c;
};

结构体变量通过点操作符(.)访问

struct S s;  //定义结构体变量
s.a = 20;  //访问结构体成员
s.b = 30;
s.c = 40;

结构体指针通过操作符(->)访问

struct S *p;  //定义结构体指针
p->a = 20;  //访问结构体成员
p->b = 30;
p->c = 40;

结构体的自引用

结构体在引用自身时，需要使用同类型的结构体指针

struct S
{
    int a;
    struct S *p; //同类型的结构体指针
};

在这里，对结构体重命名时需要注意，创建同类型的结构体指针时不可以使用重命名之后的名字

typedef struct
{
    int a;
    Node *p; //错误，Node未创建
}Node;

typedef struct Node
{
    int a;
    struct Node *p; //正确
}Node;

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

结构体变量的定义

struct S
{
    int a;
    int b;
}p1;  //声明类型的同时定义变量p1
struct S p2; //定义结构体变量p2

结构体变量的初始化

struct S p3 = { 3, 3 }; //定义变量的同时初始化

结构体内存对齐

结构体对齐的规则

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

结构体对齐的原因

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

总体来说，结构体的内存对齐是拿空间换时间的做法在设计结构体时，我们需要让占用空间小的成员尽量集中在一起

struct S1
{
    char c1;
    int a;
    char c2;
};
struct S2
{
    char c1;
    char c2;
    int a;
};

printf("%d\n", sizeof(struct S1));  //12
printf("%d\n", sizeof(struct S2));  //8
//S1和S2的成员一样，但所占用的空间大小却不同

结构体传参

struct S
{
    char c;
    int a;
};

struct S s = { 'c', 4 };

//结构体传参
print1(s);
void print1(struct S s)

print2(&s);
void print2(struct S *ps)

从函数栈帧中我们可以了解到，函数传参时参数需要压栈，如果在传递一个过大的结构体时，参数压栈时系统的开销比较大，所以会导致性能的下降

位段

位段的声明

位段的声明与结构体相似，但有两个不同：

1. 位段的成员必须是int，unsignef int，signed int 或char（整型家族）类型
2. 位段的成员名后面必须有一个冒号和一个数字

struct S1
{
    int a:2; //a仅仅需要两个比特位
    int b:5;
    int c:10;
    int d:30;
};
struct S2
{
    char a : 2;
    char b : 3;
    char c : 5;
    char d : 6;
};

位段的内存分配

位段的空间上是按照4个字节(int)或者1个字节(char)的方式开辟的

printf("%d\n", sizeof(struct S1));  //8
printf("%d\n", sizeof(struct S2));  //3

位段的跨平台问题

位段是不跨平台的

1. int位段被当成unsigned还是signed是不确定的
2. 位段中的最大位的数目不能确定
3. 位段中的成员在内存中从左向右分配还是从右向左分配标准尚未定义
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的

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

枚举——一一列举

枚举类型的定义

enum Day
{
    Mon, //注意不是；
    Tues,
    Wef,
    Thur,
    Fri,
    Sat,
    Sun
};

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

enum Day,enum Color是枚举类型

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

枚举类型的优点

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

枚举的使用

enum Color
{
    RED = 1,
    GREEN = 2,
    BLUE = 4;
};
enum Color clr = GREEN; //只能拿枚举常量给枚举变量赋初值，才不会出现类型差异

联合(共用体)

联合类型的定义

联合是一种特殊的自定义类型，这种类型定义的变量包含一系列成员，这些成员共用同一块空间

union Un
{
    char c;
    int i;
};
union Un un; //联合变量的定义

联合的特点

联合的成员是共用同一块空间的，这样一个联合变量的大小至少也是最大成员的大小(联合至少有能力保存最大的那个成员)

联合大小的计算

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

union Un1
{
    char c[5];
    int i;
};
union Un2
{
    char c[9];
    int i;
};
printf("%d\n", sizeof(union Un1));  //8 
printf("%d\n", sizeof(union Un2));  //12

联合与结构体的巧妙应用

//将long类型的Ip地址，转换位点分十进制的表示形式
union ip_addr
{
    unsigned long addr;
    struct
    {
        unsigned char c1;
        unsigned char c2;
        unsigned char c3;
        unsigned char c4;
    }ip;
};

union ip_addr my_ip;
my_ip.addr = 123456789;
//printf("%d\n", sizeof(my_ip)); //4
printf("%d.%d.%d.%d\n", my_ip.ip.c4, my_ip.ip.c3, my_ip.ip.c2, my_ip.ip.c1);