C进阶-自定义类型：结构体、枚举、联合

本章重点：

结构体：

结构体类型的声明
结构的自引用
结构体变量的定义和初始化
结构体内存对齐
结构体传参
结构体实现位段（位段的填充&可移植性）

 1 结构体的声明

 1.1 结构的基础知识

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

数组：一组相同类型元素的集合

1.2 结构的声明

// struct tag
// {
//     member-list;
// }variable-list;  //变量列表
 
struct Stu
{
    int age;
    char name[20];
    char id[20];
};
struct Stu s1,s2,s3;

1.3 特殊的声明 

在声明结构的时候吗可以不完全声明

//特殊声明
struct 
{
    int a;
    char c;
    float f;
} x;
 
struct 
{
    int a;
    char c;
    float f;
}* p;
 
int main()
{
    //p = &x; //err
 
 
    return 0;
}

1.4 结构体的自引用

 数据结构：描述的是数据在内存中的组织结构

线性数据结构： 假设要存储：1，2，3，4，5      顺序表

 

// struct Node
// {
//     int data;
//     struct Node* next;
// };
 
// typedef struct   //err
// {
//     int data;
//     Node* next;
// } Node;
 
typedef struct Node
{
    int data;
    struct Node* next;
} Node;
 
int main()
{
    Node n = {0};
 
    return 0;
}

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

struct SN
{
    //char c[20];
    char c;
    int i;
}sn1 = {'q',100},sn2 = {.i=50,.c='w'};   //全局变量
 
struct S
{
    double d;
    struct SN sn;
    int arr[10];
};
 
int main()
{
    //struct SN sn3,sn4;  //局部变量
    //printf("%c %d\n",sn2.c,sn2.i);
    //printf("%c %d\n",sn1.c,sn1.i);
    struct S s = {3.14,{'a',99},{1,2,3,4}};
    printf("%lf %c %d\n",s.d,s.sn.c,s.sn.i);
    int i = 0;
    for (i = 0; i< 10;i++)
    {
        printf("%d ",s.arr[i]);
    }
 
 
 
    return 0;
}

 1.6 结构体内存对齐

结构体内存对齐的规则：

1.结构体的第一个成员永远放在相较于结构体变量起始位置的偏移量为0的位置

2.从第二个成员开始，往后的每个成员都要对齐到某个对齐数的整数倍处。

对齐数：结构体成员自身的大小和默认对齐数的较小值

VS上默认对齐数是8

gcc 没有默认对齐数，对齐数就是结构体成员的自身大小。

3.结构体的总大小，必须上最大对齐数的整数倍

最大对齐数是：是所有成员的对齐数中的最大值

// struct S1
// {
//     char c1;
//     int i;
//     char c2;
// };
 
// struct S2
// {
//     int i;
//     char c1;
//     char c2;
// };
 
// int main()
// {
//     printf("%d\n",sizeof(struct S1)); //12
//     printf("%d\n",sizeof(struct S2));// 8
//     printf("%d\n",offsetof(struct S1,c1));//可以计算结构体成员相较于结构体起始位置的偏移量 //0
//     printf("%d\n",offsetof(struct S1,i));//4
//     printf("%d\n",offsetof(struct S1,c2));//8
//     printf("%d\n",offsetof(struct S2,i));//可以计算结构体成员相较于结构体起始位置的偏移量 //0
//     printf("%d\n",offsetof(struct S2,c1));//4
//     printf("%d\n",offsetof(struct S2,c2));//8
//     //通过上面的现象分析，我们发现结构成员不是按照顺序在内存中连续存放的，而是有一定的对齐规则的
//     return 0;
// }
 
struct S3
{
    double d;
    char c;
    int i;
};
 
struct S4
{
    char c1;
    struct S3 s3;
    double d;
};
 
 
int main()
{
    printf("%d\n",sizeof(struct S4)); //32
 
    return 0;
}

 为什么存在内存对齐？

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

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

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

 1.7 修改默认对齐数

#pragma pack(1)
struct S
{
    char c1;// 1 1 1
    int a;// 4 1 1
    char c2;// 1 1 1
};
#pragma pack(1)
 
int main()
{
    printf("%d\n",sizeof(struct S));
 
    return 0;
}

 1.8 结构体传参

struct S
{
    int data[100];
    int num;
};
 
void print1(struct S tmp)
{
    printf("%d\n",tmp.num);
}
 
//优先使用结构体传参
void print2(struct S* ps)
{
    printf("%d\n",ps->num);
}
 
int main()
{
    struct S s = {{1,2,3},100};
    print1(s);
    print2(&s);
 
    return 0;
}

2. 位段 

2.1 什么是位段

位段的声明和结构是类似的，有两个不同：

1.    位段的成员必须是 int、unsigned int 或signed int。

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

struct A
{
    int _a : 2; //二进制位
    int _b : 5;
    int _c : 10;
    int _d : 30;
 
};
 
 
int main()
{
    printf("%d\n",sizeof(struct A));
 
    return 0;
}

 2.2 位段的内存分配

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;
};
 
int main()
{
    struct S s = {0};
    s.a = 10;
    s.b = 12;
    s.c = 3;
    s.d = 4;
 
    printf("%d\n",sizeof(struct S));
 
    return 0;
}

 2.3 位段的跨平台问题

1.    int 位段被当成有符号数还是无符号数是不确定的。

2.    位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。

3.    位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4.    当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

枚举：

枚举顾名思义就是一一列举。 把可能的取值一一列举

枚举类型的定义

枚举的优点

枚举的使用

3.1 枚举类型的定义 

enum Color
{
    RED,
    GREEN = 8,
    BLUE
};
 
 
int main()
{
    enum Color c = GREEN;
    printf("%d\n",RED);
    printf("%d\n",GREEN);
    printf("%d\n",BLUE);
 
    return 0;
}

 3.2 枚举的优点

1.    增加代码的可读性和可维护性

2.    和#define定义的标识符比较枚举有类型检查，更加严谨。

3.    防止了命名污染（封装）

4.    便于调试

5.    使用方便，一次可以定义多个常量

3.3 枚举的使用 

enum Color
{
    RED = 1,
    GREEN = 8,
    BLUE = 4
};
 
 
int main()
{
    // enum Color c = GREEN;
    // printf("%d\n",RED);
    // printf("%d\n",GREEN);
    // printf("%d\n",BLUE);
 
    enum Color clr = GREEN;
    clr = 5;
 
    return 0;
}

联合：

联合类型的定义

联合的特点

联合大小的计算

 4.1 联合类型的定义

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

 

union Un
{
    char c;
    int i;
};
 
 
int main()
{
    printf("%d\n",sizeof(union Un));
    union Un un = {0};
 
    printf("%p\n",&un);
    printf("%p\n",&un.i);
    printf("%p\n",&un.c);
 
 
    return 0;
}

 4.2 联合的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。 

union Un
{
    char c;
    int i;
};
 
 
int main()
{
    printf("%d\n",sizeof(union Un));
    union Un un = {0};
    un.i = 0x11223344;
    un.c = 0x55;
    printf("%x\n", un.i);
 
    // printf("%p\n",&un);
    // printf("%p\n",&un.i);
    // printf("%p\n",&un.c);
 
 
    return 0;
}

 4.3 联合的计算

// union Un
// {
//     int i;
//     char c;
// };
 
// int main()
// {
//     printf("%d\n",sizeof(union Un));  //4
 
//     return 0;
// }
 
// int check_sys()
// {
//     union 
//     {
//         int i;
//         char c;
//     } un = {.i = 1};
 
//     return un.c;
    
// }
 
// int main()
// {
//     int ret = check_sys();
//     if(ret ==1)
//     {
//         printf("小端\n");
//     }
//     else
//     {
//         printf("大端\n");
//     }
 
//     return 0;
// }
 
union Un1
{
    char c[5]; //5 1 8 1
    int i; //4 8 4
};
 
union Un2
{
    short c[7]; //14 2 8 2
    int i; //4 4 8 4
};
 
int main()
{
    printf("%d\n",sizeof(union Un1)); //5 + 3 = 8
    printf("%d\n",sizeof(union Un2)); //14 + 2 = 16
 
    return 0;
}