熬夜整理的C语言/C++万字总结（四）

心已赠人 2022-08-29 06:11 211阅读 0赞

## 1、结构体 ##

### 1.1 结构体基础知识 ###

**1.1.1 结构体类型的定义**

struct Person{
     char name[64];
     int age;
    };
    
    typedef struct _PERSON{
     char name[64];
     int age;
    }Person;

**注意**：定义结构体类型时不要直接给成员赋值，结构体只是一个类型，编译器还没有为其分配空间，只有根据其类型定义变量时，才分配空间，有空间后才能赋值。

### [10W+字C语言硬核总结（一），值得阅读收藏！][10W_C] ###

### [10W+字C语言硬核总结（二），值得阅读收藏！][10W_C 1] ###

### [10W+字C语言硬核总结（三），值得阅读收藏！][10W_C 2] ###

### [熬夜整理的C/C++万字总结（五），文件操作][C_C] ###

### [程序员必备硬核资源，点击下载！][Link 1] ###

### [程序员书籍资源，值得收藏！][Link 2] ###

**1.1.2 结构体变量的定义**

struct Person{
     char name[64];
     int age;
    }p1; //定义类型同时定义变量
    
    struct{
     char name[64];
     int age;
    }p2; //定义类型同时定义变量
    
    struct Person p3; //通过类型直接定义

**1.1.3 结构体变量的初始化**

struct Person{
     char name[64];
     int age;
    }p1 = {"john",10}; //定义类型同时初始化变量
    
    struct{
     char name[64];
     int age;
    }p2 = {"Obama",30}; //定义类型同时初始化变量
    
    struct Person p3 = {"Edward",33}; //通过类型直接定义

**1.1.4 结构体成员的使用**

struct Person{
     char name[64];
     int age;
    };
    void test(){
     //在栈上分配空间
     struct Person p1;
     strcpy(p1.name, "John");
     p1.age = 30;
     //如果是普通变量，通过点运算符操作结构体成员
     printf("Name:%s Age:%d\n", p1.name, p1.age);
    
     //在堆上分配空间
     struct Person* p2 = (struct Person*)malloc(sizeof(struct Person));
     strcpy(p2->name, "Obama");
     p2->age = 33;
     //如果是指针变量，通过->操作结构体成员
     printf("Name:%s Age:%d\n", p2->name, p2->age);
    }

**1.1.5 结构体赋值**

**1.1.5.1 赋值基本概念**

相同的两个结构体变量可以相互赋值，把一个结构体变量的值拷贝给另一个结构体，这两个变量还是两个独立的变量。

struct Person{
     char name[64];
     int age;
    };
    
    void test(){
     //在栈上分配空间
     struct Person p1 = { "John" , 30};
     struct Person p2 = { "Obama", 33 };
     printf("Name:%s Age:%d\n", p1.name, p1.age);
     printf("Name:%s Age:%d\n", p2.name, p2.age);
     //将p2的值赋值给p1
     p1 = p2;
     printf("Name:%s Age:%d\n", p1.name, p1.age);
     printf("Name:%s Age:%d\n", p2.name, p2.age);
    }

**1.1.5.1 深拷贝和浅拷贝**

//一个老师有N个学生
    typedef struct _TEACHER{
     char* name;
    }Teacher;
    
    
    void test(){
     
     Teacher t1;
     t1.name = malloc(64);
     strcpy(t1.name , "John");
    
     Teacher t2;
     t2 = t1;
    
     //对手动开辟的内存，需要手动拷贝
     t2.name = malloc(64);
     strcpy(t2.name, t1.name);
    
     if (t1.name != NULL){
      free(t1.name);
      t1.name = NULL;
     }
     if (t2.name != NULL){
      free(t2.name);
      t1.name = NULL;
     }
    }

**1.1.6 结构体数组**

struct Person{
     char name[64];
     int age;
    };
    
    void test(){
     //在栈上分配空间
     struct Person p1[3] = {
      { "John", 30 },
      { "Obama", 33 },
      { "Edward", 25}
     };
    
     struct Person p2[3] = { "John", 30, "Obama", 33, "Edward", 25 };
     for (int i = 0; i < 3;i ++){
      printf("Name:%s Age:%d\n",p1[i].name,p1[i].age);
     }
     printf("-----------------\n");
     for (int i = 0; i < 3; i++){
      printf("Name:%s Age:%d\n", p2[i].name, p2[i].age);
     }
     printf("-----------------\n");
     //在堆上分配结构体数组
     struct Person* p3 = (struct Person*)malloc(sizeof(struct Person) * 3);
     for (int i = 0; i < 3;i++){
      sprintf(p3[i].name, "Name_%d", i + 1);
      p3[i].age = 20 + i;
     }
     for (int i = 0; i < 3; i++){
      printf("Name:%s Age:%d\n", p3[i].name, p3[i].age);
     }
    }

### 1.2 结构体嵌套指针 ###

**1.2.1 结构体嵌套一级指针**

struct Person{
     char* name;
     int age;
    };
    
    void allocate_memory(struct Person** person){
     if (person == NULL){
      return;
     }
     struct Person* temp = (struct Person*)malloc(sizeof(struct Person));
     if (temp == NULL){
      return;
     }
     //给name指针分配内存
     temp->name = (char*)malloc(sizeof(char)* 64);
     strcpy(temp->name, "John");
     temp->age = 100;
    
     *person = temp;
    }
    
    void print_person(struct Person* person){
     printf("Name:%s Age:%d\n",person->name,person->age);
    }
    
    void free_memory(struct Person** person){
     if (person == NULL){
      return;
     }
     struct Person* temp = *person;
     if (temp->name != NULL){
      free(temp->name);
      temp->name = NULL;
     }
    
     free(temp);
    }
    
    void test(){
     
     struct Person* p = NULL;
     allocate_memory(&p);
     print_person(p);
     free_memory(&p);
    }

**1.2.2 结构体嵌套二级指针**

//一个老师有N个学生
    typedef struct _TEACHER{
     char name[64];
     char** students;
    }Teacher;
    
    void create_teacher(Teacher** teacher,int n,int m){
    
     if (teacher == NULL){
      return;
     }
    
     //创建老师数组
     Teacher* teachers = (Teacher*)malloc(sizeof(Teacher)* n);
     if (teachers == NULL){
      return;
     }
    
     //给每一个老师分配学生
     int num = 0;
     for (int i = 0; i < n; i ++){
      sprintf(teachers[i].name, "老师_%d", i + 1);
      teachers[i].students = (char**)malloc(sizeof(char*) * m);
      for (int j = 0; j < m;j++){
       teachers[i].students[j] = malloc(64);
       sprintf(teachers[i].students[j], "学生_%d", num + 1);
       num++;
      }
     }
    
     *teacher = teachers; 
    }
    
    void print_teacher(Teacher* teacher,int n,int m){
     for (int i = 0; i < n; i ++){
      printf("%s:\n", teacher[i].name);
      for (int j = 0; j < m;j++){
       printf("  %s",teacher[i].students[j]);
      }
      printf("\n");
     }
    }
    
    void free_memory(Teacher** teacher,int n,int m){
     if (teacher == NULL){
      return;
     }
    
     Teacher* temp = *teacher;
    
     for (int i = 0; i < n; i ++){
      
      for (int j = 0; j < m;j ++){
       free(temp[i].students[j]);
       temp[i].students[j] = NULL;
      }
    
      free(temp[i].students);
      temp[i].students = NULL;
     }
    
     free(temp);
    
    }
    
    void test(){
     
     Teacher* p = NULL;
     create_teacher(&p,2,3);
     print_teacher(p, 2, 3);
     free_memory(&p,2,3);
    }

### 1.3 结构体成员偏移量 ###

//一旦结构体定义下来，则结构体中的成员内存布局就定下了
    #include <stddef.h>
    struct Teacher
    {
     char a;
     int b;
    };
    
    void test01(){
    
     struct Teacher  t1;
     struct Teacher*p = &t1;
    
    
     int offsize1 = (int)&(p->b) - (int)p;  //成员b 相对于结构体 Teacher的偏移量
     int offsize2 = offsetof(struct Teacher, b);
    
     printf("offsize1:%d \n", offsize1); //打印b属性对于首地址的偏移量
     printf("offsize2:%d \n", offsize2);
    }

### 1.4 结构体字节对齐 ###

## [程序员必备硬核资源，点击下载！][Link 1] ##

在用 sizeof 运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。

从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列， 而不是简单地顺序排列，这就是**内存对齐**。

**1.4.1.1 内存对齐原因**

我们知道内存的最小单元是一个字节，当 cpu 从内存中读取数据的时候，是一个一个字节读取，所以内存对我们应该是入下图这样：

![8121fa7f56015f0bc5e6bf125c12a410.png][]

但是实际上 cpu 将内存当成多个块，每次从内存中读取一个块，这个块的大小可能是2、4、8、16等，

> 那么下面，我们来分析下非内存对齐和内存对齐的优缺点在哪？

内存对齐是操作系统为了提高访问内存的策略。操作系统在访问内存的时候，每次读取一定长度(这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍)。如果没有对齐，为了访问一个变量可能产生二次访问。

> 至此大家应该能够简单明白，为什么要简单内存对齐？

*  提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。
 *  某些平台只能在特定的地址处访问特定类型的数据，否则抛出硬件异常给操作系统。

**1.4.1.1 如何内存对齐**

*  对于标准数据类型，它的地址只要是它的长度的整数倍。
 *  对于非标准数据类型，比如结构体，要遵循一下对齐原则：

1.  数组成员对齐规则。第一个数组成员应该放在offset为0的地方，以后每个数组成员应该放在offset为min（当前成员的大小，\#pargama pack(n)）整数倍的地方开始（比如int在32位机器为４字节，\#pargama pack(2)，那么从2的倍数地方开始存储）。
2.  结构体总的大小，也就是sizeof的结果，必须是min（结构体内部最大成员，\#pargama pack(n)）的整数倍，不足要补齐。
3.  结构体做为成员的对齐规则。如果一个结构体B里嵌套另一个结构体A,还是以最大成员类型的大小对齐，但是结构体A的起点为A内部最大成员的整数倍的地方。（struct B里存有struct A，A里有char，int，double等成员，那A应该从8的整数倍开始存储。），结构体A中的成员的对齐规则仍满足原则1、原则2。

手动设置对齐模数:

*  \#pragma pack(show)

显示当前packing alignment的字节数，以warning message的形式被显示。

*  \#pragma pack(push)

将当前指定的packing alignment数组进行压栈操作，这里的栈是the internal compiler stack,同事设置当前的packing alignment为n；如果n没有指定，则将当前的packing alignment数组压栈。

*  \#pragma pack(pop)

从internal compiler stack中删除最顶端的reaord; 如果没有指定n,则当前栈顶record即为新的packing alignement数值；如果指定了n，则n成为新的packing alignment值

*  \#pragma pack(n)

指定packing的数值，以字节为单位，缺省数值是8，合法的数值分别是1,2,4,8,16。

## [程序员必备硬核资源，点击下载！][Link 1] ##

**1.4.2 内存对齐案例**

#pragma pack(4)
    
    typedef struct _STUDENT{
     int a;
     char b;
     double c;
     float d;
    }Student;
    
    typedef struct _STUDENT2{
     char a;
     Student b; 
     double c;
    }Student2;
    
    void test01(){
    
     //Student
     //a从偏移量0位置开始存储
     //b从4位置开始存储
     //c从8位置开始存储
     //d从12位置开存储
     //所以Student内部对齐之后的大小为20 ，整体对齐，整体为最大类型的整数倍 也就是8的整数倍 为24
    
     printf("sizeof Student:%d\n",sizeof(Student));
    
     //Student2 
     //a从偏移量为0位置开始 
     //b从偏移量为Student内部最大成员整数倍开始，也就是8开始
     //c从8的整数倍地方开始,也就是32开始
     //所以结构体Sutdnet2内部对齐之后的大小为：40 ， 由于结构体中最大成员为8，必须为8的整数倍 所以大小为40
     printf("sizeof Student2:%d\n", sizeof(Student2));
    }

[10W_C]: https://blog.csdn.net/weixin_41055260/article/details/118947036
[10W_C 1]: https://blog.csdn.net/weixin_41055260/article/details/119054624
[10W_C 2]: https://blog.csdn.net/weixin_41055260/article/details/119153223
[C_C]: https://blog.csdn.net/weixin_41055260/article/details/119342331
[Link 1]: https://download.csdn.net/download/weixin_41055260/20298620
[Link 2]: https://blog.csdn.net/weixin_41055260/article/details/119257422
[8121fa7f56015f0bc5e6bf125c12a410.png]: /images/20220829/88c15a1af2ec4243b4ebb6dd4fe45f30.png