• C++学习笔记（九）

    一、结构体

    1. 结构体概述

    有时我们需要将不同类型的数据组合成一个有机的整体，如：

    一个学生有学号，姓名，性别，年龄，地址等属性：

    1. int num;
    2. char name[20];
    3. char sex;
    4. int age;
    5. char addr[40];

    单独定义以上变量比较繁琐，数据不便于管理。

    C++提供struct关键字，可以将不同类型封装在一起，形成新的结构叫做“结构体”

    1. struct Student
    2. {
    3.     int num;
    4.     char name[20];
    5.     char sex;
    6.     int age;
    7.     char addr[40];
    8. };

    2. 结构体定义

    1. struct 结构体类型名
    2. {
    3.     成员列表;
    4. }; // 注意此处有分号

    如：

    1. // 定义结构体类型
    2. // 系统不会为结构体类型开辟空间，只会为结构体类型定义的变量开辟空间
    3. struct Student
    4. {
    5.     // int num = 10; // 定义结构体类型时 不要给成员初始化值
    6.     int num; // 结构体成员
    7.     char name[20]; 
    8. };
    9. // 结构体中的成员拥有独立的空间
    10.  
    11. // 结构体定义变量
    12. Student lucy; // lucy为结构体变量名
    13. Student bob; // bob为结构体变量名

    访问结构体变量中成员的方法：变量.成员名

    结构体类型的三种定义方法：

    ①.  先定义结构体类型，再定义结构体变量(推荐)

    1. struct student
    2. {
    3.     int num;
    4.     char name[20];
    5. };
    6.  
    7. student lucy;

    ②. 定义结构体类型的同时，定义结构体变量

    1. struct student
    2. {
    3.     int num;
    4.     char name[20];
    5. }lucy;
    6.  
    7. student bob;

    ③. 定义一次性结构体类型

    1. struct
    2. {
    3.     int num;
    4.     char name[20];
    5. }lucy;

    3. 结构体变量的操作

    ①. 结构体变量的初始化

    结构体变量如果不初始化，变量中的成员内容不确定（随机值）

    结构体变量的初始化必须遵循成员的顺序以及成员自身的数据类型

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     Stu lucy = {"lucy",20};
    15.     cout << lucy.name << "的年龄是:" << lucy.age << endl;
    16.     return 0;
    17. }

    ②. 清空整个结构体变量

    有时候不需要给结构体变量初始化，但又不希望其成员内容随机，就需要使用memset清空结构体变量

    1. void *memset(void *dest, int val, size_t n);
    2. 将地址从dest开始长度为n的所有字节赋值为val
    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     Stu lucy;
    15.     // 清空整个结构体变量
    16.     memset(&lucy,0,sizeof(lucy));
    17.     cout << lucy.name << "的年龄是:" << lucy.age << endl; // 的年龄是:0
    18.     return 0;
    19. }

    ③. 键盘给结构体变量中成员赋值

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     Stu lucy;
    15.     // 清空整个结构体变量
    16.     memset(&lucy,0,sizeof(lucy));
    17.     cout << "请输入学生的姓名和年龄:";
    18.     cin >> lucy.name >> lucy.age;
    19.     cout << lucy.name << "的年龄是:" << lucy.age << endl;
    20.     return 0;
    21. }

    ④. 单独操作结构体中成员

    单独操作结构体中成员必须遵循结构体自身的类型

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     Stu lucy = {"lucy",20};
    15.     // name成员是数组名,符号常量，不允许使用=给name赋值
    16.     // lucy.name = "bob"; // erro
    17.     strcpy(lucy.name,"bob");
    18.     lucy.age += 10;
    19.     cout << lucy.name << "的年龄是:" << lucy.age << endl;
    20.     return 0;
    21. }

    ⑤. 相同类型的结构体变量之间赋值的方法

    三种方法

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     Stu lucy = {"lucy",20};
    15.     Stu bob1,bob2,bob3;
    16.  
    17.     // 第一种方法：逐个成员赋值（遵循成员类型）
    18.     strcpy(bob1.name,lucy.name);
    19.     bob1.age = lucy.age;
    20.  
    21.     // 第二种方法：相同类型的结构体变量可以直接赋值（推荐）
    22.     bob2 = lucy;
    23.  
    24.     // 第三种方法：内存拷贝（第二种的底层实现）
    25.     memcpy(&bob3,&lucy,sizeof(Stu));
    26.  
    27.     cout << "bob1:" << bob1.name << "的年龄是:" << bob1.age << endl;
    28.     cout << "bob2:" << bob2.name << "的年龄是:" << bob2.age << endl;
    29.     cout << "bob3:" << bob3.name << "的年龄是:" << bob3.age << endl;
    30.     return 0;
    31. }

    ⑥. 结构体嵌套结构体

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Birthday
    7. {
    8.     int year;
    9.     int month;
    10.     int day;
    11. };
    12.  
    13. struct Stu
    14. {
    15.     char name[20];
    16.     int age;
    17.     Birthday bd;
    18. };
    19.  
    20. int main(int argc, char *argv[])
    21. {
    22.     Stu lucy = {"lucy",20,{2002,12,9}};
    23.  
    24.     cout << lucy.name << "的生日是:" << lucy.bd.year << "年" << lucy.bd.month << "月" << lucy.bd.day << "日" << endl;
    25.     cout << lucy.name << "的年龄是:" << lucy.age << endl;
    26.     return 0;
    27. }

    结构体嵌套结构体注意访问到最底层

    4. 结构体数组

    结构体数组：本质是数组，只是数组的每个元素为结构体变量

    ①. 结构体数组初始化

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Birthday
    7. {
    8.     int year;
    9.     int month;
    10.     int day;
    11. };
    12.  
    13. struct Stu
    14. {
    15.     char name[20];
    16.     int age;
    17.     Birthday bd;
    18. };
    19.  
    20. int main(int argc, char *argv[])
    21. {
    22.     Stu student[3] = {{"lucy",20,{2002,12,9}},{"bob",22,{2000,3,11}},{"poppy",18,{2004,6,6}}};
    23.  
    24.     // 清空数组
    25.     // memset(student,0,sizeof(student));
    26.  
    27.     int n = sizeof(student)/sizeof(student[0]);
    28.     for(int i=0;i
    29.     {
    30.         cout << student[i].name << "的生日是:" << student[i].bd.year << "年" << student[i].bd.month << "月" << student[i].bd.day << "日" << endl;
    31.         cout << student[i].name << "的年龄是:" << student[i].age << endl;
    32.         cout << "----------------------------" << endl;
    33.     }
    34.     return 0;
    35. }

    ②. 键盘给结构体赋值

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Birthday
    7. {
    8.     int year;
    9.     int month;
    10.     int day;
    11. };
    12.  
    13. struct Stu
    14. {
    15.     char name[20];
    16.     int age;
    17.     Birthday bd;
    18. };
    19.  
    20. int main(int argc, char *argv[])
    21. {
    22.     Stu student[3];
    23.     // {"lucy",20,{2002,12,9}},{"bob",22,{2000,3,11}},{"poppy",18,{2004,6,6}}
    24.     memset(student,0,sizeof(student));
    25.     int n = sizeof(student)/sizeof(student[0]);
    26.     for(int i=0;i
    27.     {
    28.         cout << "请输入学生的姓名和出生年日月:";
    29.         cin >> student[i].name >> student[i].bd.year >> student[i].bd.month >> student[i].bd.day;
    30.         student[i].age = 2022 - student[i].bd.year;
    31.     }
    32.  
    33.     for(int i=0;i
    34.     {
    35.         cout << student[i].name << "的生日是:" << student[i].bd.year << "年" << student[i].bd.month << "月" << student[i].bd.day << "日" << endl;
    36.         cout << student[i].name << "的年龄是:" << student[i].age << endl;
    37.         cout << "----------------------------" << endl;
    38.     }
    39.     return 0;
    40. }

    5. 结构体指针变量

    结构体的指针变量：本质是变量，只是该变量保存的是结构体变量的地址

    ①. 结构体指针变量的定义

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     Stu lucy = {"lucy",20};
    15.     Stu *p = &lucy;
    16.  
    17.     // *p == lucy
    18.     cout << lucy.name << "的年龄是:" << lucy.age << endl;
    19.     cout << (*p).name << "的年龄是:" << (*p).age << endl;
    20.  
    21.     // 通过指针变量使用 -> 访问成员
    22.     cout << p->name << "的年龄是:" << p->age << endl;
    23.     cout << (&lucy)->name << "的年龄是:" << (&lucy)->age << endl;
    24.  
    25.     // 如果是地址可以直接使用 -> 访问成员；如果是结构体变量，使用 . 访问成员
    26.     return 0;
    27. }

    ②. 结构体数组元素的指针变量

    指针变量保存结构体数组元素的地址

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     char name[20];
    9.     int age;
    10. };
    11.  
    12. void inputStu(Stu *arr, int n)
    13. {
    14.     for(int i=0;i
    15.     {
    16.         cout << "请输入学生姓名和年龄:";
    17.         cin >> arr[i].name >> arr[i].age;
    18.     }
    19. }
    20.  
    21. void sortStu(Stu *arr, int n)
    22. {
    23.     cout << "正在按年龄大小排序中，请稍候... ..." << endl;
    24.     for(int i=0;i-1;i++)
    25.     {
    26.         for(int j=0;j-1;j++)
    27.         {
    28.             if(arr[j].age>arr[j+1].age)
    29.             {
    30.                 Stu temp = arr[j];
    31.                 arr[j] = arr[j+1];
    32.                 arr[j+1] = temp;
    33.             }
    34.         }
    35.     }
    36.     cout << "排序完成... ..." << endl;
    37. }
    38.  
    39. void outputStu(Stu *arr, int n)
    40. {
    41.     for(int i=0;i
    42.     {
    43.         cout << arr[i].name << "的年龄是:" << arr[i].age << endl;
    44.     }
    45. }
    46.  
    47. int main(int argc, char *argv[])
    48. {
    49.     Stu student[5];
    50.     memset(student,0,sizeof(student));
    51.     int n = sizeof(student)/sizeof(student[0]);
    52.  
    53.     // 输入函数
    54.     inputStu(student,n);
    55.  
    56.     // 排序函数
    57.     sortStu(student,n);
    58.  
    59.     // 输出函数
    60.     outputStu(student,n);
    61.     return 0;
    62. }

    6. 结构体的指针成员

    ①. 结构体的指针成员定义

    1. struct Stu
    2. {
    3.     int num;
    4.     char *name;
    5. };
    6.  
    7. Stu lucy = {100,"hello world"};

    指针变量只有四字节，无法保存字符串整体，所以lucy.name保存时“hello world”的首元素地址，而“hello world”字符串本身存储再文字常量区

    ②. 结构体指针成员指向堆区

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     int age;
    9.     char *name;
    10. };
    11.  
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     Stu lucy;
    16.     lucy.age = 100;
    17.     lucy.name = new char[32];
    18.     strcpy(lucy.name,"hello world");
    19.     cout << lucy.age << " " << lucy.name << endl;
    20.     delete [] lucy.name;
    21.     return 0;
    22. }

    ③. 结构体的浅拷贝

    相同类型的结构体变量可以整体赋值，默认赋值方式为：浅拷贝

    浅拷贝：将结构体变量空间内容赋值一份到另一个相同类型的结构体变量空间中

    如果结构体中没有指针成员，浅拷贝不会带来问题

    如果结构体中有指针成员，浅拷贝会带来多次释放空间的问题（多个指针变量指向同一空间，会导致同一空间被释放多次）

    1. struct Stu
    2. {
    3.     char *name;
    4.     int age;
    5. };
    6.  
    7. Stu lucy;
    8. lucy.name = new char[32];
    9. strcpy(lucy.name,"lucy");
    10. lucy.age = 20;
    11.  
    12. Stu bob;
    13. bob = lucy;
    14.  
    15. delete [] lucy.name;
    16. delete [] bob.name;

    ④. 结构体的深拷贝

    如果结构体中有指针成员，尽量使用深拷贝

    深拷贝：为结构体的指针成员分配独立空间，再将内容拷贝

    1. struct Stu
    2. {
    3.     char *name;
    4.     int age;
    5. };
    6.  
    7. Stu lucy;
    8. lucy.name = new char[32];
    9. strcpy(lucy.name,"lucy");
    10. lucy.age = 20;
    11.  
    12. Stu bob;
    13. bob.age = lucy.age;
    14. bob.name = new char[32];
    15. strcpy(bob.name,lucy.name);
    16.  
    17. delete [] lucy.name;
    18. delete [] bob.name;

    ⑤. 结构体变量在堆区，结构体的指针成员也指向堆区

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     int age;
    9.     char *name;
    10. };
    11.  
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     // 结构体在堆区
    16.     Stu *p = new Stu;
    17.  
    18.     // 结构体中指针成员指向堆区
    19.     p->name = new char[32];
    20.  
    21.     // 赋值
    22.     p->age = 20;
    23.     strcpy(p->name,"lucy");
    24.  
    25.     cout << p->name << "的年龄是:" << p->age << endl;
    26.  
    27.     // 释放空间,显示放成员指向，再释放结构体
    28.     delete [] p->name;
    29.     delete p;
    30.  
    31.     return 0;
    32. }

    7. 结构体对齐规则

    1. struct Data
    2. {
    3.     char a;
    4.     int b;
    5. };

    不对齐：

    abbbb
    0x000x010x020x030x040x050x060x07

    访问a：只需要一个周期 0x00 —0x03，数据只需要0x00

    访问b：需要两个周期

                     第一个周期：0x00—0x03，数据需要 0x01—0x03

                     第二个周期：0x04—0x07，数据需要0x04，最后和0x01—0x03拼接

    对齐：

    abbbb
    0x000x010x020x030x040x050x060x07

    访问a：只需要一个周期 0x00 —0x03，数据只需要0x00

    访问b：只需要一个周期 0x04—0x07

    结构体自动对齐规则

    1. 确认分配单位（一行分配多少字节）

    结构体中最大的基本类型长度决定

    2. 确认成员的偏移量

    成员偏移量 = 成员自身类型的整数倍

    3. 收尾工作

    结构体的总大小 = 分配单位的整数倍

    强制对齐规则

    #program pack(value) 时的指定对齐值value

    注意value值为1 2 4 8 16

    1. 确定分配单位（一行分配多少字节）

    分配单位 = min(结构体中最大的基本类型，value)

    2. 确认成员的偏移量

    成员偏移量 = 成员自身类型的整数倍

    3. 收尾工作

    结构体的总大小 = 分配单位整数倍

    1. #program pack(8)
    2. struct A
    3. {
    4.     char a;
    5.     int b;
    6.     short c;
    7. };

    min(结构体中最大的基本类型，value) = 4

    a
    bbbb
    cc
    1. #program pack(2)
    2. struct A
    3. {
    4.     char a;
    5.     int b;
    6.     short c;
    7. };

    min(结构体中最大的基本类型，value) = 2

    a
    bb
    bb
    cc

    8. 结构体的位域

    ①. 结构体位域的概述

    在结构体中，以位为单位的成员，称之为位段（位域）

    1. struct packed_data
    2. {
    3.     unsigned int a:2;
    4.     unsigned int b:6;
    5.     unsigned int c:4;
    6.     unsigned int d:4;
    7.     unsigned int i;
    8. }data;

    a的类型是 unsigned int a 的大小只占2位二进制位

    没有非位域隔开的位域叫相邻位域

    相同类型的相邻位域可以压缩，但是压缩的位数不能超过自身类型的大小

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct A
    7. {
    8.     unsigned char a:2;
    9.     unsigned char b:2;
    10.     unsigned char c:4;
    11. };
    12.  
    13. int main(int argc, char *argv[])
    14. { 
    15.     cout << "结构体A的大小为:" << sizeof(A) << endl; // 1
    16.     return 0;
    17. }

    a占一个字节的两位，b占一个字节的两位，c占一个字节的三位，相同类型的相邻位域压缩后大小为一字节

    不要对位域取地址

    地址是以字节为单位分配地址编号的，最少为一个字节

    对位域的操作不要超过自身的宽度

    1. #include 
    2. #include
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. struct A
    8. {
    9.     unsigned char a:2;
    10.     unsigned char b:2;
    11.     unsigned char c:4;
    12. };
    13.  
    14. int main(int argc, char *argv[])
    15. {
    16.     A num;
    17.     num.a = 11; // 1011
    18.     cout << "输出是:" << bitset<2>(num.a) << endl; // 11
    19.     // 只输出了低二位
    20.     return 0;
    21. }

    ②. 另起一个存储单元

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct A
    7. {
    8.     unsigned char a:4;
    9.     unsigned char b:4;
    10. };
    11.  
    12. struct B
    13. {
    14.     unsigned char a:4;
    15.     unsigned char :0; // 另起一个存储单元
    16.     unsigned char b:4;
    17. };
    18. int main(int argc, char *argv[])
    19. {
    20.     cout << "结构体A的大小为:" << sizeof(A) << endl; // 1
    21.     cout << "结构体B的大小为:" << sizeof(B) << endl; // 2
    22.     return 0;
    23. }

    ③. 无意义位段

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct A
    7. {
    8.     unsigned char a:4;
    9.     unsigned char :2;
    10.     unsigned char b:2;
    11. };
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     cout << "结构体A的大小为:" << sizeof(A) << endl; // 1
    16.     return 0;
    17. }

    ④. 案例

    8位寄存器

    addraddr    opt opt     datadata
    xyabmn

    addr：

    00设备1
    01设备2
    10设备3
    11设备4

    opt：

    00建立连接
    01发送
    10接收
    11关闭连接

    data：

    00关
    01开

    需求：给设备3发送开灯指令

    10x01x01
    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct REG
    7. {
    8.     unsigned char data:2;
    9.     unsigned char :1;
    10.     unsigned char opt:2;
    11.     unsigned char :1;
    12.     unsigned char addr:2;
    13. };
    14.  
    15. int main(int argc, char *argv[])
    16. {
    17.     REG reg;
    18.     reg.addr = 2;
    19.     reg.opt = 1;
    20.     reg.data = 1;
    21.     return 0;
    22. }

    二、共用体

    结构体：所有成员拥有独立空间

    共用体：所有成员共享一块空间

    共用体关键字：union

    共用体的空间是由最大的成员类型决定的

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. union Data
    7. {
    8.     char a;
    9.     short b;
    10.     int c;
    11. };
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     Data data;
    16.     data.a = 10;
    17.     data.b = 20;
    18.     data.c = 30;
    19.     cout << data.a+data.b+data.c << endl; // 30+30+30=90
    20.     // 共用体共用同一空间
    21.     return 0;
    22. }

    成员a，b，c共享同一块空间，但是每个成员能操作的空间的范围是由成员自身类型长度决定的

    1. #include 
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. union Data
    7. {
    8.     char a;
    9.     short b;
    10.     int c;
    11. };
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     Data data;
    16.     data.c = 0x01020304;
    17.     data.b = 0x0102;
    18.     data.a = 0x01;
    19.     cout << hex << data.a+data.b+data.c << endl; // 0x01020203
    20.     return 0;
    21. }
    data.c04030201
    data.b02010201
    data.a01010201
    data.a01000000
    data.b01010000
    data.c01010201
    data.a+data.b+data.c03020201

    答案为：0x01020203

    三、枚举

    枚举：将枚举变量要赋的值一一列举出来

    1. #include 
    2. #include
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. enum POKER_COLOR{HongTao,MeiHua,FangKuai,HeiTao};
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     POKER_COLOR my = HongTao;
    12.     cout << my << endl; // 0
    13.     cout << HongTao << endl << MeiHua << endl << FangKuai << endl << HeiTao << endl;
    14.     // 0 1 2 3,其值是默认从0开始递增
    15.     return 0;
    16. }

    如果修改某个枚举列表的值

    1. #include 
    2. #include
    3. #include
    4.  
    5. using namespace std;
    6.  
    7. enum POKER_COLOR{HongTao,MeiHua=10,FangKuai,HeiTao};
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     POKER_COLOR my = HongTao;
    12.     cout << my << endl; // 0
    13.     cout << HongTao << endl << MeiHua << endl << FangKuai << endl << HeiTao << endl;
    14.     // 0 10 11 12,递增
    15.     return 0;
    16. }

  • 相关阅读:
    Java之原子性问题的解决
    共享内存和信号量的配合机制
    5年迭代5次，抖音推荐系统演进历程
    【算法篇】动态规划（二）
    dubbo参数调优说明
    【leetcode】【剑指offer】【二进制中1的个数】
    第8章_瑞萨MCU零基础入门系列教程之SCI SPI
    音视频服务架构演进
    mybatis-plus3.5.3.1 支持不同数据源sql适配
    VMware 与戴尔正式“分手”
  • 原文地址：https://blog.csdn.net/zh20001109zh/article/details/127851126