• C++ 语言学习 day11 复习（3）

    1.第一个是昨天的作业： 用类实现一个双向循环链表， 完成对应的功能，（增删查改 ）

    代码：

    list.h

    1. #ifndef LIST_H
    2. #define LIST_H
    3. #include <iostream>
    4. #include <string.h>
    5. using namespace std;
    6.  
    7. #define Type int //宏定义
    8. typedef unsigned int u32;//无符号整型
    9. /***** 节点的结构体 ****/
    10. struct Node
    11. {
    12.     Node():data(new Type),prev(NULL),next(NULL)
    13.     {
    14.         memset(data,0,sizeof(Type));    /*清零数据*/
    15.     }/*构造函数:申请空间*/
    16.     ~Node(){delete data;}/*析构函数:释放空间*/
    17.  
    18.     Type *data; /*数据域*/
    19.     Node *prev; /*前驱*/
    20.     Node *next; /*后继*/
    21. };
    22.  
    23. /****** 链表的结构体 ******/
    24. class List
    25. {
    26. public:
    27.     List() /*链表构造函数*/
    28.     {
    29.         /*1.申请空间*/
    30.         m_head = new Node;
    31.         /*2.更改指向*/
    32.         m_head->next = m_head;
    33.         m_head->prev = m_head;
    34.         /*3.初始化元素个数*/
    35.         m_size = 0;
    36.     }
    37. //    List(const List &list) /*链表拷贝构造*/
    38. //        :List()/*1.调用无参构造*/
    39. //    {
    40. //        /*2.拷贝list表的数据到this表中*/
    41. //        /*调用链表尾部增加 push_back()*/
    42. //    }
    43.     ~List()
    44.     {
    45.         clear();    /*清空非表头节点*/
    46.         delete m_head;/*释放表头*/
    47.     }
    48. public: /* 公有接口 */
    49.     bool push_back(const Type &value)/*链表尾部增加*/
    50.     {
    51.         return insert(m_head,value);
    52. //        /*1.新增节点*/
    53. //        Node *node = new Node;
    54. //        /*2.拷贝数据到新节点空间*/
    55. //        *node->data = value;
    56. //        /*3.找到要插入位置的前后节点*/
    57. //        Node *prev = m_head->prev;
    58. //        Node *next = m_head;
    59. //        /*4.更改指向*/
    60. //        node->prev = prev;
    61. //        node->next = next;
    62.  
    63. //        prev->next = node;
    64. //        next->prev = node;
    65. //        /*5.元素个数+1*/
    66. //        m_size++;
    67. //        return true;
    68.     }
    69.     bool push_front(const Type &value)/*链表头部增加*/
    70.     {
    71.         return insert(m_head->next,value);
    72.     }
    73.     bool insert(Node *insert_node,const Type &value)/*链表任意节点位置插入*/
    74.     {
    75.         /*1.新增节点*/
    76.         Node *node = new Node;
    77.         /*2.拷贝数据到新节点空间*/
    78.         *node->data = value;
    79.         /*3.找到要插入位置的前后节点*/
    80.         Node *prev = insert_node->prev;
    81.         Node *next = insert_node;
    82.         /*4.更改指向*/
    83.         node->prev = prev;
    84.         node->next = next;
    85.  
    86.         prev->next = node;
    87.         next->prev = node;
    88.         /*5.元素个数+1*/
    89.         m_size++;
    90.  
    91.         return true;
    92.     }
    93.     bool insert(u32 index,Type &value)/*链表任意插入*/
    94.     {
    95.         if(index > m_size) index = m_size;
    96.         /**** 找到要插入位置的节点 ****/
    97.         Node *node = m_head->next;
    98.  
    99.         for(u32 i = 0; i < index;i++)
    100.         {
    101.             node = node->next;
    102.         }
    103.         /**** 插入数据 ****/
    104.         return insert(node,value);
    105.     }
    106.     bool pop_back()/*链表尾部删除*/
    107.     {
    108.         if(m_size == 0) return false;
    109.         return erase(m_head->prev);
    110.     }
    111.     bool pop_front()/*链表头部删除*/
    112.     {
    113.         if(m_size == 0) return false;
    114.         return erase(m_head->next);
    115.     }
    116.     bool erase(int index)/*链表任意删除节点*/
    117.     {
    118.         if(m_size == 0 || index >= m_size) return false;
    119.  
    120.         /*** 1.找到要删除的节点 ****/
    121.         Node *node = m_head->next;
    122.         for(int i = 0; i < index;i++)
    123.         {
    124.             node = node->next;
    125.         }
    126.  
    127.         /*** 2.删除节点 ****/
    128.         return erase(node);
    129.     }
    130.     bool erase(Node *node)
    131.     {
    132.         /*** 1.找到前驱和后继 ***/
    133.         Node *prev = node->prev;
    134.         Node *next = node->next;
    135.  
    136.         /*** 2.释放节点 *****/
    137.         delete node;
    138.  
    139.         /*** 3.修改指向 ****/
    140.         prev->next = next;
    141.         next->prev = prev;
    142.  
    143.         /*** 4.元素个数-1 **/
    144.         m_size--;
    145.         return true;
    146.     }
    147.     void clear()/*清空链表*/
    148.     {
    149.         while(m_size != 0)
    150.         {
    151.             pop_back();/*尾部删除*/
    152.         }
    153.     }
    154.     bool remove(const Type &value)/*删除第一个匹配的值 : 会调用 == 运算符重载*/
    155.     {
    156.         /*** 1.找到匹配节点 ****/
    157.         Node *node = m_head->next;
    158.  
    159.         while(node != m_head)
    160.         {
    161.             if(*node->data == value)
    162.             {
    163.                 /**** 删除该节点 ****/
    164.                 return erase(node);
    165.             }
    166.             node = node->next;  /*往后遍历*/
    167.         }
    168.  
    169.         return false;
    170.     }
    171.     template <class _Predicate>/*虚拟类型*/
    172.     bool remove_if(_Predicate Predicate) /*删除第一个匹配的值 : 一元谓词: bool func(Type value) */
    173.     {
    174.         /*** 1.找到匹配节点 ****/
    175.         Node *node = m_head->next;
    176.  
    177.         while(node != m_head)
    178.         {
    179.             if( Predicate(*node->data) == true)
    180.             {
    181.                 /**** 删除该节点 ****/
    182.                 return erase(node);
    183.             }
    184.             node = node->next;  /*往后遍历*/
    185.         }
    186.  
    187.         return false;
    188.     }
    189.     void remove_all(const Type &value)/*删除所有匹配的值: 会调用 == 运算符重载*/
    190.     {
    191.         /**** 1.找到匹配节点 ****/
    192.         while(remove(value) == true);
    193.  
    194.     }
    195.     template <class _Predicate>/*虚拟类型*/
    196.     void remove_all_if(_Predicate Predicate)/*删除所有匹配的值: 一元谓词: bool func(Type value)*/
    197.     {
    198.         /**** 1.找到匹配节点 ****/
    199.         while(remove_if(Predicate) == true);
    200.  
    201.     }
    202.     Type &front()/*返回链表第一个元素*/
    203.     {
    204.         return *m_head->next->data;
    205.     }
    206.     Type &back()/*返回链表最后一个元素*/
    207.     {
    208.         return *m_head->prev->data;
    209.     }
    210.     Type &operator [](u32 index) const/*提供随机访问*/
    211.     {
    212.         if(index >= m_size)
    213.         {
    214.             cout << "链表没有元素个数,爆出异常" << endl;
    215.             throw "异常:链表没有元素个数"; /*报异常*/
    216.         }
    217.  
    218.         Node *node = m_head->next;  /*第一个元素*/
    219.         for(u32 i = 0; i < index;i++)
    220.         {
    221.             node = node->next; /*往后遍历*/
    222.         }
    223.  
    224.         return *node->data;
    225.     }
    226.     u32 size() const    /*获取元素的个数*/
    227.     {
    228.         return m_size;
    229.     }
    230.     Type &find(Type value)
    231.     {
    232.         /*** 1.找到匹配节点 ****/
    233.         Node *node = m_head->next;
    234.  
    235.         while(node != m_head)
    236.         {
    237.             if(*node->data == value)
    238.             {
    239.                 /**** 返回该节点数据 ****/
    240.                 break;
    241.             }
    242.             node = node->next;  /*往后遍历*/
    243.         }
    244.  
    245.         return *node->data;
    246.     }
    247.     template <class _Predicate>/*虚拟类型*/
    248.     Type &find_if(_Predicate Predicate)
    249.     {
    250.         /*** 1.找到匹配节点 ****/
    251.         Node *node = m_head->next;
    252.  
    253.         while(node != m_head)
    254.         {
    255.             if(Predicate(*node->data))
    256.             {
    257.                 /**** 返回该节点数据 ****/
    258.                 break;
    259.             }
    260.             node = node->next;  /*往后遍历*/
    261.         }
    262.  
    263.         return *node->data;
    264.     }
    265.     static void sort(int *addr,int len) /*冒泡排序:调用 > 运算符重载 */
    266.     {
    267. //        int addr[];
    268. //        int len = 0;
    269.         bool flag = false;/*记录是否排好序,排好序:false,未排好序:true*/
    270.  
    271.         int temp = 0;/*临时变量,用于交换*/
    272.         for(int i = 0; i < len - 1;i++)
    273.         {
    274.             flag = false;/*清空数据,用于下次记录*/
    275.             for(int j = 0; j < len - i - 1;j++)
    276.             {
    277.                 if(addr[j] > addr[j+1])
    278.                 {
    279.                     flag = true;/*表名没有排好序*/
    280.                     /*交换*/
    281.                     temp = addr[j];
    282.                     addr[j] = addr[j+1];
    283.                     addr[j+1] = temp;
    284.                 }
    285.             }
    286.             if(flag == false) break;    /*检测是否排好序,排好需就直接退出*/
    287.         }
    288.     }
    289.  
    290.     void sort()
    291.     {
    292.         bool flag = false;/*记录是否排好序,排好序:false,未排好序:true*/
    293.         Type *temp = NULL;/*临时指针,用于交换*/
    294.  
    295.         Node *node_i = NULL;
    296.         Node *node_j = NULL;
    297.  
    298.         /****** 排序 *******/
    299.         for(node_i = m_head->next ; node_i != m_head->prev ; node_i = node_i->next)
    300.         {
    301.             flag = false;/*清空数据,用于下次记录*/
    302.             for(node_j = m_head->next;node_j != m_head->prev ; node_j = node_j->next)
    303.             {
    304.                 if(*node_j->data > *node_j->next->data)
    305.                 {
    306.                     flag = true;/*表名没有排好序*/
    307.                     /*交换*/
    308.                     temp = node_j->data;
    309.                     node_j->data = node_j->next->data;
    310.                     node_j->next->data = temp;
    311.                 }
    312.             }
    313.             if(flag == false) break;    /*检测是否排好序,排好需就直接退出*/
    314.         }
    315.     }
    316.  
    317. /***** 接口使用 *****/
    318. protected:
    319.     Node *m_head;   /* 节点:表头 */
    320.     u32 m_size;     /* 元素个数 */
    321. };
    322.  
    323. #endif // LIST_H
    324.

    main.cpp

    1. #include <iostream>
    2. #include "list.h"
    3. using namespace std;
    4. void Print(const List &list);
    5.  
    6. int main()
    7. {
    8.     List list;
    9.  
    10.     for(int i = 0 ; i < 10;i++)
    11.     {
    12.         list.push_front(i);
    13.     }
    14.  
    15.     cout << "排序前:";
    16.     for(u32 i = 0; i < list.size();i++)
    17.     {
    18.         cout << list[i] << ",";
    19.     }
    20.     cout << endl;
    21.  
    22.     list.sort();
    23.  
    24.     cout << "排序后:";
    25.     for(u32 i = 0; i < list.size();i++)
    26.     {
    27.         cout << list[i] << ",";
    28.     }
    29.     cout << endl;
    30.  
    31.     return 0;
    32. }
    33.  
    34.  
    35. int test2()
    36. {
    37.     int addr[10] = {123,1234,236,437,64,51,6,6756,845,85};
    38.     int len = 10;
    39.  
    40.     cout << "未排序addr : ";
    41.     for(int i = 0; i < len;i++)
    42.     {
    43.         cout << addr[i] << ",";
    44.     }
    45.     cout << endl;
    46.  
    47.     List::sort(addr,len);
    48.  
    49.     cout << "已排序addr : ";
    50.     for(int i = 0; i < len;i++)
    51.     {
    52.         cout << addr[i] << ",";
    53.     }
    54.     cout << endl;
    55. }
    56.  
    57.  
    58.  
    59.  
    60.  
    61.  
    62.  
    63.  
    64.  
    65.  
    66.  
    67.  
    68.  
    69.  
    70.  
    71. int test1()
    72. {
    73.     List list;
    74.  
    75.     for(int i = 0; i < 10; i++)
    76.     {
    77.         //list.push_back(i); /*尾部插入:0,1,2,3,4,5,6,7,8,9*/
    78.         //list.insert(0,i);/*头部插入*/
    79.         list.insert(list.size(),i);/*尾部插入*/
    80.     }
    81.     cout << "第一个元素:" << list.front() << endl;
    82.     cout << "最后的元素:" << list.back() << endl;
    83.  
    84.     /**** 删除头尾 ****/
    85.     list.pop_back();
    86.     list.pop_front();
    87.     cout << "输出list结构的数据:" << endl;
    88.     Print(list);
    89.  
    90.     /**** 删除下标位 3的位置 *****/
    91.     list.erase(3);
    92.     cout << "输出list结构的数据:" << endl;
    93.     /**** 清空 ****/
    94.     //list.clear();
    95.  
    96.     //list.remove(6);
    97.     list.push_back(5);
    98.     list.push_front(5);
    99.  
    100.     //list.remove_all(5);
    101.     Print(list);
    102.  
    103.     cout << "调用带 自定义策略的函数" << endl;
    104.     bool int_cmp(Type value);   /*函数类声明函数*/
    105.     list.remove_all_if(int_cmp);
    106.     Print(list);
    107.  
    108.     cout << "查询 3" << endl;
    109.     int value = list.find(10);
    110.     cout << "value = " << value << endl;
    111.  
    112.     cout << "查询大于 5" << endl;
    113.     value = list.find_if([/*依赖*/](Type value/*参数列表*/)->bool/*返回值类型*/{
    114.                 /*匿名函数的函数体*/
    115.                 if(value > 5) return true;
    116.                 return false;
    117.             });
    118.     cout << "value = " << value << endl;
    119.  
    120.     cout << "程序正常结束" << endl;
    121.     return 0;
    122. }
    123.  
    124. bool int_cmp(Type value)
    125. {
    126.     if(value > 5) return true;
    127.     return false;
    128. }
    129.  
    130. void Print(const List &list)
    131. {
    132.     for(u32 i = 0; i < list.size();i++)
    133.     {
    134.         cout << list[i] << ",";
    135.     }
    136.     cout << endl;
    137. }

    2.继承，

    /********* 多继承会造成的问题 *************************
     * 1.父类成员同名问题?
     *      答:使用类域调用解决
     * 2.菱形继承(砖石继承)?:
     *      人类
     *  学生    工人
     *     实习生
     *   答:使用虚继承方式,形成续表索引(32位机:虚指针占4字节)
     * *************************************************/

    父类成员同名问题?
     *      答:使用类域调用解决

    代码：

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. class Student   /*学生*/
    5. {
    6. public:
    7.     string m_name;  /*姓名*/
    8.     int m_age;      /*年龄*/
    9.     float m_score = 0;  /*分数*/
    10. public:
    11.     void study(){cout << "学习" << endl;}
    12.     void exam(){ cout << "考试" << endl;}
    13. };
    14.  
    15. class Worker    /*工人*/
    16. {
    17. public:
    18.     string m_name;  /*姓名*/
    19.     int m_age;      /*年龄*/
    20.     int m_salary = 0; /*薪水*/
    21. public:
    22.     void wage(int hour)
    23.     {
    24.         int salary = 20 * hour;
    25.         m_salary += salary;
    26.         cout << "工作:" << hour << "小时,赚取:" << salary << "薪水" << endl;
    27.     }
    28. };
    29.  
    30. /* 实习生,继承于 学生 和 工人 */
    31. class Trainee : public Student , public Worker
    32. {
    33. public:
    34.     void sleep(){ cout << "我是实习生" << endl;}
    35. };
    36.  
    37. /********* 多继承会造成的问题 *************************
    38.  * 1.父类成员同名问题?
    39.  *      答:使用类域调用解决
    40.  * 2.菱形继承(砖石继承)?:
    41.  *      人类
    42.  *  学生    工人
    43.  *     实习生
    44.  *   答:使用虚继承方式,形成续表索引(32位机:虚指针占4字节)
    45.  * *************************************************/
    47.  
    48. int main()
    49. {
    50.     Trainee trainee;
    51.  
    52.     cout << "m_score = " << trainee.m_score << endl;
    53.     cout << "m_salary = " << trainee.m_salary << endl;
    54.  
    55.     /******** 使用成员同名变量 ********/
    56.     trainee.Student::m_name = "王老师";
    57.     trainee.Worker::m_name = "王无敌";
    58.  
    59.     cout << "name = " << trainee.Student::m_name << endl;
    60.     cout << "name = " << trainee.Worker::m_name << endl;
    61.  
    62.     return 0;
    63. }

    虚继承方式,形成续表索引

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. class People
    5. {
    6. public:
    7.     string m_name;  /*姓名*/
    8.     int m_age;      /*年龄*/
    9. };
    10.  
    11. class Student : virtual public People  /*学生*/
    12. {
    13. public:
    14.     float m_score = 0;  /*分数*/
    15. public:
    16.     void study(){cout << "学习" << endl;}
    17.     void exam(){ cout << "考试" << endl;}
    18. };
    19.  
    20. class Worker : virtual public People    /*工人*/
    21. {
    22. public:
    23.     int m_salary = 0; /*薪水*/
    24. public:
    25.     void wage(int hour)
    26.     {
    27.         int salary = 20 * hour;
    28.         m_salary += salary;
    29.         cout << "工作:" << hour << "小时,赚取:" << salary << "薪水" << endl;
    30.     }
    31. };
    32.  
    33. /* 实习生,继承于 学生 和 工人 */
    34. class Trainee : public Student , public Worker
    35. {
    36. public:
    37.     void sleep(){ cout << "我是实习生" << endl;}
    38. };
    39. /********* 多继承会造成的问题 *************************
    40.  * 1.父类成员同名问题?
    41.  *      答:使用类域调用解决
    42.  * 2.菱形继承(砖石继承)?:
    43.  *      人类
    44.  *  学生    工人    -> 这里使用虚继承 virtual public People
    45.  *     实习生
    46.  *   答:使用 virtual 虚继承方式,形成续表索引(32位机:虚指针占4字节)
    47.  * 3.虚继承的好处
    48.  * *************************************************/
    49. int main()
    50. {
    51. #if 0
    52.     /**** 探讨大小 ***/
    53.     cout << "sizeof(string) = " << sizeof(string) << endl;  //24字节
    54.     cout << "sizeof(People) = " << sizeof(People) << endl;  //28字节
    55.  
    56.     cout << "sizeof(Student)= " << sizeof(Student) << endl; //32字节
    57.     cout << "sizeof(Worker) = " << sizeof(Worker)  << endl; //32字节
    58.  
    59.     cout << "sizeof(Trainee)= " << sizeof(Trainee) << endl; //64字节
    60. #else
    61.     /*—— 通过以上可以看出,我共同继承于人类部分多余了,只用一份空间就行,所以照成空间浪费——*/
    62.     /*答:使用 virtual 虚继承方式解决多该案例多占用 28 字节,但是 virtual是虚指针所以需要占用 4字节空间*/
    63.     /**** 探讨大小 ***/
    64.     cout << "sizeof(string) = " << sizeof(string) << endl;  //24字节
    65.     cout << "sizeof(People) = " << sizeof(People) << endl;  //28字节
    66.  
    67.     cout << "sizeof(Student)= " << sizeof(Student) << endl; //32+4字节
    68.     cout << "sizeof(Worker) = " << sizeof(Worker)  << endl; //32+4字节
    69.  
    70.     cout << "sizeof(Trainee)= " << sizeof(Trainee) << endl; //64+8-28字节
    71.     /*———————————— 通过以上案例,得出已经只占用一片空间 ————————————*/
    72. #endif
    73.     Trainee trainee;
    74.     trainee.m_name = "老师";
    75.     cout << "姓名:" << trainee.People::m_name << endl;
    76.     cout << "姓名:" << trainee.Student::m_name << endl;
    77.     cout << "姓名:" << trainee.Worker::m_name << endl;
    78.     cout << "姓名:" << trainee.Trainee::m_name << endl;
    79.     return 0;
    80. }

    3.多态 （）

    多态的定义：

    多态是C++面向对象三大特性之一 多态分为两类： ◼静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 ◼动态多态: 派生类和虚函数实现运行时多态（重写)

    静态多态和动态多态区别： ◼静态多态的函数地址早绑定 - 编译阶段确定函数地址 ◼动态多态的函数地址晚绑定 - 运行阶段确定函数地址

    总结： 多态满足条件： ◼有继承关系 ◼子类重写父类中的虚函数(”虚“会被继承) 多态使用条件： ◼父类指针或引用指向子类对象 重写：函数返回值类型 函数名 参数列表 完全一致称为重写

    多态的优点

    多态的优点： ◼代码组织结构清晰 ◼可读性强 ◼利于前期和后期的扩展以及维护 总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

    代码：（加强版）

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. class People
    5. {
    6. public:
    7.     /**** 虚函数 -> Qt里面 函数名变成斜体字 ****/
    8.     virtual void study()
    9.     {
    10.         cout << "自我摸索学习" << endl;
    11.     }
    12. public:
    13.     string m_name;
    14.     int m_age;
    15. };
    16.  
    17. class Student : public People
    18. {
    19. public:
    20.     void study()    /* -> 重写 */
    21.     {
    22.         cout << "跟着大牛老师学习" << endl;
    23.     }
    24. };
    25.  
    26. class Teacher : public People
    27. {
    28. public:
    29.     void study()    /* -> 重写 */
    30.     {
    31.         cout << "看国际论坛博文学习" << endl;
    32.     }
    33. };
    34.  
    35. class Librarian : public People
    36. {
    37. public:
    38.     void study()    /* -> 重写 */
    39.     {
    40.         cout << "看图书学习" << endl;
    41.     }
    42. };
    43.  
    44. class Programmer : public Student
    45. {
    46. public:
    47.     void study()    /* -> 重写 */
    48.     {
    49.         cout << "百度CP复制学习" << endl;
    50.     }
    51. };
    52.  
    53. #include <list> /*链表   // STL容器*/   
    54.  
    55. void Print_study(People &value1)
    56. {
    57.     value1.study();/*打印学习方法*/
    58. }
    59. int main()
    60. {
    61.     Student student;
    62.     Teacher teacher;
    63.     Programmer programmer;
    64.  
    65.     Print_study(student);
    66.     Print_study(teacher);
    67.     Print_study(programmer);
    68.  
    69. #if 0
    70.     list<People *> list_v;
    71.  
    72.     /******* 插入 *******/
    73.     list_v.push_back(new People);
    74.     list_v.push_back(new Student);
    75.     list_v.push_back(new Programmer);
    76.     list_v.push_back(new Librarian);
    77.     list_v.push_back(new Teacher);
    78.  
    79.     /******* 遍历 *******/
    80.     list<People *>::iterator it;
    81.     for(it = list_v.begin();it != list_v.end();it++)
    82.     {   /** it 遍历出来的指针 **/
    83.         (*it)->study();
    84.     }
    85. #endif
    86.  
    87.     return 0;
    88. }

    代码（普通版）

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. /***** 饮品制作的基类 *****/
    6. class Beverage
    7. {
    8. public:
    9.     virtual void boil() = 0;            /*煮水*/
    10.     virtual void brewing() = 0;         /*冲泡*/
    11.     virtual void with_cup() = 0;        /*倒入杯中*/
    12.     virtual void ingredients() = 0;     /*加入辅料*/
    13.  
    14. public:
    15.     void make()/*制作*/
    16.     {
    17.         boil();
    18.         brewing();
    19.         with_cup();
    20.         ingredients();
    21.     }
    22. };
    23.  
    24. /***** 制作咖啡 ****/
    25. class Coffee : public Beverage
    26. {
    27. public:
    28.     void boil()
    29.     {
    30.         cout << "煮矿泉水" << endl;
    31.     }
    32.  
    33.     void brewing()
    34.     {
    35.         cout << "冲泡咖啡" << endl;
    36.     }
    37.  
    38.     void with_cup()
    39.     {
    40.         cout << "倒入咖啡杯中" << endl;
    41.     }
    42.  
    43.     void ingredients()
    44.     {
    45.         cout << "加入红糖和牛奶" << endl;
    46.     }
    47. };
    48.  
    49. class Tea : public Beverage
    50. {
    51. public:
    52.     void boil()
    53.     {
    54.         cout << "煮山泉水" << endl;
    55.     }
    56.  
    57.     void brewing()
    58.     {
    59.         cout << "冲泡茶叶" << endl;
    60.     }
    61.  
    62.     void with_cup()
    63.     {
    64.         cout << "倒入茶杯中" << endl;
    65.     }
    66.  
    67.     void ingredients()
    68.     {
    69.         cout << "加入枸杞,人生片" << endl;
    70.     }
    71. };
    72.  
    73. void make(Beverage &beverage)
    74. {
    75.     beverage.make();
    76. }
    77. int main()
    78. {
    79.     Coffee coffee;
    80.     Tea tea;
    81.  
    82.     make(coffee);
    83.     make(tea);
    84.  
    85.     return 0;
    86. }

    4.多态的时候，开辟空间需要加上 （虚析构！！）

    虚析构和纯虚析构

    多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码 解决方式：将父类中的析构函数改为虚析构或者纯虚析构

    虚析构和纯虚析构共性： ◼可以解决父类指针释放子类对象 ◼都需要有具体的函数实现 虚析构和纯虚析构区别： ◼如果是纯虚析构，该类属于抽象类，无法实例化对象

    虚析构语法：virtual ~类名(){} 纯虚析构语法：virtual ~类名() = 0;

    总结： ◼ 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象 ◼ 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构 ◼ 拥有纯虚析构函数的类也属于抽象类

    代码：

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. class A
    5. {
    6. public:
    7.     A(){cout << __func__ << endl;}
    8.     virtual ~A(){cout << __func__ << endl;}  //这里可以尝试把 virtual 去掉 调试试试
    9. };
    10.  
    11. class B :public A
    12. {
    13. public:
    14.     B(){cout << __func__ << endl;}
    15.     ~B(){cout << __func__ << endl;}
    16. };
    17.  
    18. /**** 一般在调用多态时会造成内存泄漏,可以使用虚析构或纯虚析构解决实现 ****/
    19. int main()
    20. {
    21.     A *a = new B;   /* A()      */
    22.     delete a;       /* ~A()     */
    23.  
    24.     return 0;
    25. }
    26.

    5.文件操作

    C++中对文件操作需要包含头文件 < fstream >

    文件类型分为两种：

    1. 文本文件 - 文件以文本的ASCII码形式存储在计算机中
    2. 二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

    操作文件的三大类:

    1. ofstream：写操作
    2. ifstream： 读操作
    3. fstream ： 读写操作

    10.1文本文件

    10.1.1写文件

    写文件步骤如下：

    1. 包含头文件

      #include

    2. 创建流对象

      ofstream ofs;

    3. 打开文件

      ofs.open(“文件路径”,打开方式);

    4. 写数据

      ofs << “写入的数据”;

    5. 关闭文件

      ofs.close();

    代码：

    1. #include <iostream>
    2. #include <fstream>  /* 文件流类 */
    3. using namespace std;
    4.  
    5. class Student
    6. {
    7. public:
    8.     Student(string name = "",int age = 0):m_name(name),m_age(age){}
    9.     string m_name;
    10.     int m_age;
    11. };
    12.  
    13.  
    14. /********** 操作集 ***************************************************************************
    15.  * 打开:
    16.  *  void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out)
    17.  *  void open(const std::string& __s,ios_base::openmode __mode = ios_base::in | ios_base::out)
    18.  *  参数:
    19.  *      @char* __s: C语言风格文件名
    20.  *      @string s : C++风格文件名
    21.  *      @ios_base::openmode mode : 打开模式
    22.  *              ios_base::in        写模式
    23.  *              ios_base::out       读模式
    24.  *              ios_base::trunc     创建
    25.  *              ios_base::binary    二进制
    26.  *              ios_base::app       追加
    27.  *————————————————————————————————————————————————————————————————————————————————————————————
    28.  * 关闭:
    29.  *  void close()
    30.  *————————————————————————————————————————————————————————————————————————————————————————————
    31.  * 判断是否打开成功:
    32.  *  bool is_open() const
    33.  *  返回值:
    34.  *      成功: true
    35.  *      失败: false
    36.  *——————————————————————————————————————————————————————————————————————————————————————————————
    37.  *格式化读取:
    38.  *  operator >>
    39.  *格式化写入:
    40.  *  operator <<
    41.  *——————————————————————————————————————————————————————————————————————————————————————————————
    42.  *块写入:
    43.  *  write(const char_type* __s, streamsize __n)
    44.  *块读取:
    45.  *  read(char_type* __s, streamsize __n)
    46.  *——————————————————————————————————————————————————————————————————————————————————————————————
    47.  *字节写入:
    48.  *  put(char_type __c)
    49.  *字节读取:
    50.  *  int_type get()
    51.  *———————————————————————————————————————————————————————————————————————————————————————————————
    52.  *读取一行:
    53.  *  getline(char_type* __s, streamsize __n)
    54.  * *************************************************************************************************/
    55. #include <string.h>
    56. int main()
    57. {
    58.     /* 1.实例化对象 */
    59.     fstream fd;
    60.  
    61.     /* 2.打开文件 */
    62. #if 0
    63.     fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
    64. #else
    65.     fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
    66. #endif
    67.     /* 3.判断是否打开成功 */
    68.     if(fd.is_open() == false)
    69.     {
    70.         cout << "文件打开失败:文件不存在" << endl;
    71.         return -1;
    72.     }
    73.  
    74.     /* 4.读写操作 */
    75. #if 0
    76.  
    77. #else
    78.     char buf[128] = "";
    79.     fd.getline(buf,128);
    80.     cout << "buf = " << buf << endl;
    81. #endif
    82.     /* 5.关闭文件 */
    83.     fd.close();
    84.  
    85.     return 0;
    86. }
    87.  
    88.  
    89. int test3()
    90. {
    91.     /* 1.实例化对象 */
    92.     fstream fd;
    93.  
    94.     /* 2.打开文件 */
    95. #if 0
    96.     fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
    97. #else
    98.     fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
    99. #endif
    100.     /* 3.判断是否打开成功 */
    101.     if(fd.is_open() == false)
    102.     {
    103.         cout << "文件打开失败:文件不存在" << endl;
    104.         return -1;
    105.     }
    106.  
    107.     /* 4.读写操作 */
    108. #if 0
    109.     char buf[128] = "老师xxx";
    110.     for(int i = 0; i < strlen(buf);i++)
    111.     {
    112.         fd.put(buf[i]);
    113.     }
    114. #else
    115.     char ch = 0;
    116.     while(fd.eof() == false)
    117.     {
    118.         ch = fd.get();
    119.         cout << ch;
    120.     }
    121.     cout << endl;
    122. #endif
    123.     /* 5.关闭文件 */
    124.     fd.close();
    125.  
    126.     return 0;
    127. }
    128.  
    129.  
    130.  
    131. int test2()
    132. {
    133.     /* 1.实例化对象 */
    134.     fstream fd;
    135.  
    136.     /* 2.打开文件 */
    137. #if 0
    138.     fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
    139. #else
    140.     fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
    141. #endif
    142.     /* 3.判断是否打开成功 */
    143.     if(fd.is_open() == false)
    144.     {
    145.         cout << "文件打开失败:文件不存在" << endl;
    146.         return -1;
    147.     }
    148.  
    149.     /* 4.读写操作 */
    150. #if 0
    151.     char buf[128] = "老师,无敌";
    152.     fd.write(buf,128); /*写入一块*/
    153. #else
    154.     char buf[128] = "";
    155.     fd.read(buf,128);
    156.     cout << "buf = " << buf << endl;
    157. #endif
    158.     /* 5.关闭文件 */
    159.     fd.close();
    160.  
    161.     return 0;
    162. }
    163.  
    164. int test0()
    165. {
    166.     /* 1.实例化对象 */
    167.     fstream fd;
    168.  
    169.     /* 2.打开文件 */
    170. #if 0
    171.     fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
    172. #else
    173.     fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
    174. #endif
    175.     /* 3.判断是否打开成功 */
    176.     if(fd.is_open() == false)
    177.     {
    178.         cout << "文件打开失败:文件不存在" << endl;
    179.         return -1;
    180.     }
    181.  
    182.     /* 4.读写操作 */
    183.  
    184. #if 0
    185.     Student stu1("王老师",18);
    186.     Student stu2("李老师",19);
    187.     fd << stu1.m_name << " " << stu1.m_age << endl;
    188.     fd << stu2.m_name << " " << stu2.m_age << endl;
    189. #else
    190.     while(fd.eof() == false)
    191.     {
    192.         Student stu1;
    193.         fd >> stu1.m_name >> stu1.m_age;
    194.         if(stu1.m_age != 0)
    195.             cout << "姓名:" << stu1.m_name << "\t年龄:" << stu1.m_age << endl;
    196.     }
    197. #endif
    198.     /* 5.关闭文件 */
    199.     fd.close();
    200.  
    201.     return 0;
    202. }
    203.  
    204.

  • 相关阅读:
    女性气虚胃寒怎么办 六招可祛寒补气
    单体微服务的测试策略
    「Java核心面试系列」Spring面试核心49问（附答案）
    Redis中SDS简单动态字符串
    面试官上来就让手撕HashMap的7种遍历方式，当场愣住，最后只写出了3种
    毕业了校园卡怎么改套餐？
    服务器环境搭建
    Ceph单节点部署
    软考高级论文真题“论湖仓一体架构及其应用”
    centos7安装k8s 1.24.3版本 Error getting node“ err=“node \“master01\“ not found
  • 原文地址：https://blog.csdn.net/she666666/article/details/128024549