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

1.结构体

结构体是一些值的集合

1.结构体的声明

1）下面的代码是声明一个结构体类型struct Stu

struct Stu
{
    char name[20];
    int age;
    char sex[5];
};

2）声明的时候可使用typedef关键字将结构体类型重定义

typedef struct Stu
{
    char name[20];
    int age;
    char sex[5];
}Stu;

Stu为结构体类型struct Stu的重定义

3）声明的时候可以直接在结构体类型后定义结构体变量

struct Stu
{
    char name[20];
    int age;
    char sex[5];
}stu;

stu为定义的结构体变量

3）匿名结构体类型的声明

struct
{
    char name[20];
    int age;
    char sex[5];
}x;

x即为匿名结构体变量

2.结构体的成员及访问

2.1结构体的成员

1）结构体是一些值的集合，这些值就叫做结构体的成员
2）结构体的成员可以是标量，数组，指针，其他结构体

2.1结构体的成员的访问

要对结构体的成员的访问，有两种方式：
1）结构体变量.结构体成员

typedef struct Stu
{
    char name[20];
    int age;
    char sex[5];
}Stu;

int main()
{
    Stu s;
    strcpy(s.name, "lmf");
    s.age = 10;
    strcpy(s.sex, "nan");

    return 0;
}

2）结构体的指针->结构体成员

typedef struct Stu
{
    char name[20];
    int age;
    char sex[5];
}Stu;

int main()
{
    Stu s;
    strcpy((&s)->name, "lmf");
    s.age = 10;
    strcpy((&s)->sex, "nan");

    return 0;
}

在定义结构体变量的时候可以直接初始化结构体成员

typedef struct Stu
{
    char name[20];
    int age;
    char sex[5];
}Stu;

int main()
{
    Stu s = { "lmf", 20, "nan" }
    return 0;
}

3.结构体的内存对齐

存在内存对齐的主要原因：
1）跨平台性（移植性）
并不是所有的硬件平台都可以任意的访问内存中任意位置的数据
2）效率
为了访问未对齐的数据，处理器要做两次内存访问；未对齐的数据，处理器只需要做一次内存访问，着相当于用空间去换时间，提高程序执行效率
内存对齐规则
1）第一个成员必须在结构体变量偏移量为0的地址处
2）之后的每个成员对齐到对齐数的整数倍的地址处
对齐数：编译器默认对齐数和该成员大小的较小值
默认对齐数：vs是8 linux是4
3）结构体总大小为最大对齐数的整数倍
4）如果结构体中嵌套了结构体，嵌套的结构体对齐到该结构体的最大对齐数的整数倍的地址处，结构体总大小为最大对齐数（包括嵌套的结构体的对齐数）的整数倍
内存分析示意图
定义如下结构体变量

struct Stu
{
    char c1;
    int a;
    char c2;
}s;

1）c1为第一个成员放在结构体变量偏移量为0的地址处.
2）n为int类型，大小为4，vs默认对齐数为8，所以对齐数为两者的较小值4，因为0已用，1，2，3都不是4的整数倍，所以n只能放在结构体变量偏移量为4的地址处.
3）c2为char类型，大小为1，vs默认对齐数为8，所以对齐数为两者的较小值1，因为0~7已用，8正好是1的整数倍，所以就把c2放在结构体变量偏移量为8的地址处.
4）因为结构体的总大小必须是最大对齐数的整数倍，而这个结构体的最大对齐数为4，9不是4的整数倍，所以结构体的总大小为12

4.结构体传参

下面是两个用来打印结构体中的name成员，传的参数分别是结构体和结构体的指针
两个函数都能实现相同的功能

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
typedef struct Stu
{
    char name[20];
    int age;
}Stu;
//结构体作为参数
void print1(struct Stu s)
{
    printf("%s\n", s.name);
}
//结构体的指针作为参数
void print2(struct Stu *p)
{
    printf("%s\n", p->name);
}
int main()
{
    Stu s = { "lmf", 20 };
    print1(s);
    print2(&s);
    return 0;
}

注意：
1）结构体作为参数，形参是实参的一份临时拷贝，改变形参不会影响实参；形参会将实参全部数据都拷贝一份，这样会影响效率
2）结构体的指针作为参数，只是将结构体的地址传过去，可以改变结构体成员的值，因为只传了一个地址，效率也会高

5.位段

位段与结构体的区别：
1）位段的成员只能是int，unsigned int，signed int或char（也属于整型）
2）位段的成员名后面有一个冒号和一个数字（表示该成员占几个bit位）
位段的内存分配
位段的空间是按需要来开辟的，每次开辟成员类型大小（int是4，char是1）的字节
位段的定义

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

};

位段的大小
首先开辟4个字节的空间，_a放后还剩余32bit，可以继续放_b，_b放后还有27bit，可以继续放_c，_b放后还有17bit，而_d需要30bit，空间不够，就需要在开辟4字节的空间，所以这个位段的大小就是8个字节
位段的跨平台问题
1）int位段被当做有符号数还是无符号数是不确定的
2）位段中最大位的数目不确定（比如int在不同位数的机器中最大数目不同）
3）位段中的成员在内存中的分配方式没有标准定义（可能是从右向左分配，也可能是从左向右分配）
4）当一个结构体包含有多个位段，剩下的空间若不够下一个位段使用，那么是舍弃剩余位，还是利用是不确定的
位段相较与结构体的区别
优点：位段可以节省空间
缺点：存在跨平台问题

6.枚举

枚举就是把可能的值意义列举
枚举类型的定义
若不对这些赋值，那么默认从0开始，一次增加1

enum Color
{
    RED,
    YELLOW,
    BLUE
};

在定义的时候可以赋值

enum Color
{
    RED=1,
    YELLOW=3,
    BLUE=5
};

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

7.联合（共用体）

联合类型的特点是所有的成员公用一块空间
联合类型的定义

union Un
{
    char c;
    int a;
};

联合大小的计算

#include <stdio.h>
union Un1
{
    char c[5];
    int a;
}un1;

union Un2
{
    short s[7];
    int a;
}un2;
int main()
{
    printf("%d\n", sizeof(un1));//结果为8
    printf("%d\n", sizeof(un2));//结果为16

    return 0;
}

1）联合的大小至少是最大成员的大小
2）联合的最大成员如果不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍
通过联合来判断机器的大小端存储

#include <stdio.h>
union Un
{
    char c;
    int a;
}un;

char check_sys()
{
    un.a = 1;
    return un.c;//如果是小端返回1
}
int main()
{
    if (check_sys() == 1)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}

通过联合将long类型的ip地址转化为点分十进制形式

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
union IP
{
    unsigned long num;
    unsigned char c[4];
}ip;


int main()
{
    ip.num = 178354678;
    printf("%u.%u.%u.%u\n", ip.c[0], ip.c[1], ip.c[2], ip.c[3]);
    return 0;
}