结构体

参考视频：https://www.bilibili.com/video/BV1oi4y1g7CF?p=58

大纲：

1. 结构体的声明

2. 结构体的自引用

3. 结构体内存对齐

4. 结构体传参

5. 结构体实现位段(位段的填充&可移植性)

   ---

   char short int long short float double -这些都叫做内置类型，是C语言自己的类型

   对于一些复杂对象，光用内置函数是不够的。

   复杂类型(自定义类型)-结构体、枚举、联合体。

1.结构体的声明

1. 结构体的基础知识：结构体是一些值的集合，这些值称为成员变量。结构体的每个成员可以是不同类型的变量。

   ---

   结构体的声明

   struct Stu//随便定义名字
   {
      member-list;
   }vairable-list;

例如描述一个学生

#include<stdio.h>
//声明一个结构题类型
//声明一个学生类型，通过学生类型来创建学生变量(对象)
//描述学生；属性-名字-电话-性别
struct Stu
{
    //下面这些叫做成员变量
    char name[20];//名字
    char tele[12];//电话
    int age;//年龄
    char sex[5];//性别
    char id[20];//学号
}s4, s5, s6;//变量列表;//分号不能丢
//全局变量 上面的s4~6也是
struct Stu s3;
int main(void)
{   
    //创建结构体变量
    struct Stu s1;
    struct Stu s1;

    return 0;
}

特殊的声明

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

//匿名结构体类型 没给结构体名字
struct 
{
    int a ;
    char b ;
    float c;   
}x;//没有结构体名字，只有一种创建方式，赶紧用这个匿名结构体类型的变量列表创建一个x，否则以后就创建不了了，因为该结构体没有具体的名字。
struct 
{
    int a ;
    char b ;
    float c;   
}a[20],*p;
//上面两个结构在声明的时候省略掉了结构体标签(tag)
//p = &x;是不合法的，编译器会把上面的两个声明当成完全不同的两个类型。所以是非法的。

2.结构的自引用

---

数据结构：数据在内存中的存储结构

---

错误自引用

struct Node
{
    int data; // 4
    struct Nod n; //4
    //n里面包含n,程序报错。//类似于递归的思路
};
int main(void)
{   
    sizeof(struct Node);
    return 0;
}

正确方式：结构体能够找到同类型的其他的变量，用指针串连起来。

//存放数据的地方叫数据域 存放地址的地方叫指针域
struct Node
{
    int data; // 4
    struct Node* next; //4
};
int main(void)
{   

    return 0;
}

typedef重命名

typedef struct Node  //自引用的时候不建议省略名称
{
    int data;

}Node;//结尾的这个Node是类型名，不是变量名

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

结构体变量的初始化

//初始化结构体中的结构体
struct T
{
    double weight;
    short age;
}
struct S
{
    char c;
    struct T sy;
    int a ;
    double d;
    char arr[20];
}
int main(void)
 {
    //结构体初始化的时候用大括号
    struct S s = {'c'，{2.21,2},100,3.14，'hello sb'};
    //结构体成员的访问
    printf("%c %d %lf %s\n",s.c,s.a,s.d,s.arr);
    printf("%lf",s.st.weight);
    return 0;
 }

4.结构体内存对齐

struct S1
{   
    char C1;
    int a;
    char c2;
};
struct S1
{   
    char C1;
    char c2;
    int a;
};
int main(void)
{   
    struct S1 s1 = {0};//一个0 将里面所有的内容都初始化0
    struct S2 s2= {0};
    printf("%d",sizeof(s2));// 12
    printf("%d",sizeof(s2));// 8
    return 0;
}

结构体的对齐规则：

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

2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

对齐数=编译器默认的一个对齐数与该成员大小的较小值。

VS中默认的值是8 gcc编译器没有默认对齐数。

3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

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

为什么存在内存对齐？

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

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

总的来说：

​ 结构体的内存对齐是拿空间来换取时间的做法。提升一下效率。

如何设计结构体

既要满足对齐，又要节省空间。

​ 让占用空间小的成员尽量集中在一起。

例如：

struct S1
{
    char c1;
    int i;
    char c2;
};
struct S2
{
    char c1;
    char c2;
    int i;
};
S1和S2的结构体成员一模一样，但是S1和S2所占空间的大小有了一些区别。

修改默认对齐数

#pragma pack()

#include<stdio.h>
#pragma pack(4)//设置默认对齐数为4
//默认对齐数设置为1，其实就没有对齐了，就该是什么就往里面放什么了。
struct S
{
    char a;
    double d;   

};
#pragma pack()//取消设置的默认对齐数
int main(void)
{   
    struct S s;
    printf("%d\n",sizeof(s));
    return 0;
}

结论：

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

offsetof()——结构体成员相对于结构体起始位置的偏移量

头文件——#include

(结构体名字,结构体成员)

struct S
{
    char c;
    int i;
    double d;
};
int main(void)
{
    printf("%d",offsetof(struct S,c));
    return 0;
}

5.结构体传参

类似于：函数内部想改变函数外部的某个值的话，就要传地址进去。

（->是C语言和C++语言的一个运算符，叫做指向结构体成员运算符，用处是使用一个指向结构体或对象的指针访问其内成员。）

#include<stdio.h>
struct S
{
    int a;
    char c;
    double d;
};
void Init(struct S* ps)
{
    ps->a = 100;
    ps->c = 'w';
    ps->d = 3.14;
}
//传值
void Print(struct S tmp)
{
    printf("%d %c %lf\n",tmp.a,tmp.c,tmp.d);  
}
//传值
//如果害怕就打印一个值而传值过来可能会导致值的改变，就加一个const
//综合考虑建议结构体传参传地址
void Print(const struct S* ps)
{
    printf("%d %c %lf\n",ps->a,ps->c,ps->d);
}
int main(void)
{
    struct S s = {};
    Init(&s);
    Print1(s);
    Print2(&s);
    return 0;
}

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

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

---

位段

1.什么是位段

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

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

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

比如
struct A
{
    int_a:2;
     int_b:5;
    int_c:10;
    int_d:30;
};
A就是一个位段类型
那位段A的大小是多少？

#include<stdio.h>
//位段 位是二进制位
struct S
{
    //后面的：是所对应变零需要的比特位
    int a:2;
    int b:5;
    int c:10;
    int d:30;
    //一共47个比特位——6个字节就够了*8=48bit
};
int main(void)
{
   struct S s；
  printf("%d\n",sizeof(s));//占8个字节
}

2.位段的内存分配

1位段成员可以是int unsigned int signed int 或者是char（属于整型家族）类型。

2位段的空间上是按照需要以4个字节或者1个字节（char)的方式开辟的。

3位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

在定义位段的变量中，最后一个不能大于32

#include<stdio.h>
struct S
{
    char a : 3;
    char b : 4;
    char c : 5;
    char d : 4;
};
int main(void)
{   
    struct S s = {0};
    s.a = 10;
    s.b = 20;
    s.c = 3;
    s.d = 4;
    return 0;
}

3.位段的跨平台问题

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

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

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

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

总结：

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

枚举

枚举故名思义就是一一列举

把可能的取值一一列举

1.定义

enum Day//星期
{
    //枚举的可能取值
    Mon,
    Tus,
    ...
};

enum Sex//星期
{
    //枚举的可能取值—— 常量
    MALE,//0
    FEMALE,//1      可以在后面加入 = 给他一个初始值
    //如果前面的赋值了，后面的没有赋值，就按顺序往下延。

    SECRET//2

};
int main(void)
{   
    //规定好了它的取值
    //enum是类型
    enum Sex s = MALE;
    //S
    return 0;
}

---

enum Color
{
    red,//0
    green,//1
    blue//2
}
int main(void)
{
    //在上面定义的枚举常量中green所对应的值就是2，那么我们在这可不可以直接给s赋值为2呢？
    //可以看到编译器并没有报错，说明编译器的语法检测不严格。
    //2在这里是整型
    //Color是枚举类型，两侧的类型是有差异的
    //在c++中会报错，c++语法检测更为严格
    enum Color s =;
    //
    return 0;
}

---

#include<stdio.h>
#define red 0
#define green 1
#define blue 2
int main(void)
{   
    int color = red;
    return 0;
}
//枚举的写法比这个要更加好一些

2.枚举的优点

为什么使用枚举？

我们可以使用#define来定义常量，使用枚举的优点是什么呢。

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

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

3防止命名污染（命名冲突)（封装）。

封装就是把数据和函数打包到一个类里面

4便于调试。

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

---

程序的执行过程

c语言的源代码--预编译-链接-可执行程序

这里的预编译就是在处理#define之类的东西

预编译会把所有的注释都删除

---

enum的大小怎么算呢

#incldue<stdio.h>
enum sex
{
    male,
    female,
    secret

}
int main(void)
{   
    enum sex s male;
    printf("%d\n",sizeof(s));
    return 0;
}

联合（共用体）

1.联合类型的定义

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

#include<stdio.h>
union sb
{
    char c;//一个字节
    int a;//四个字节
};
//4个字节
int main(void)
{
    union sb s;
    printf("%p\n", &s);
    printf("%p\n", &(s.c));//注意是句号
    printf("%p\n", &(s.a));
    //三个地址相同

    return 0;
}

2.特点

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

联合体内的成员不能同时使用

---

结构体、枚举、联合体的关键字不一样，性质也不一样

---

3.联合大小的计算

联合的大小至少是最大成员的大小。

当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。