• CPP 核心编程6-多态

     

    1. #include "iostream"
    2. using namespace std;
    3.  
    4. //多态
    5. class Animal
    6. {
    7. public:
    8.     void speak()
    9.     {
    10.         cout << "动物在说话" << endl;
    11.     }
    12. };
    13.  
    14. class Cat : public Animal
    15. {
    16. public:
    17.     void speak()
    18.     {
    19.         cout << "cat在说话" << endl;
    20.     }
    21. };
    22.  
    23. //地址早绑定  在编辑阶段确定函数地址
    24. //如果想执行让猫说话,那么这个函数地址就不能提前绑定,需要在运行阶段进行绑定,地址晚绑定
    25. void speak(Animal &animal) // Animal & animal = cat;
    26. {
    27.     animal.speak();
    28. }
    29. int main()
    30. {
    31.     Cat cat;
    32.     speak(cat); //输出的是动物在说话
    33.     return 0;
    34. }
    35. 动物在说话

    想要让猫说话就需要将Animal 的speak方法定义为虚函数

    1. #include "iostream"
    2. using namespace std;
    3.  
    4. //多态
    5. class Animal
    6. {
    7. public:
    8.     //虚函数
    9.     virtual void speak()
    10.     {
    11.         cout << "动物在说话" << endl;
    12.     }
    13. };
    14.  
    15. class Cat : public Animal
    16. {
    17. public:
    18.     void speak()
    19.     {
    20.         cout << "cat在说话" << endl;
    21.     }
    22. };
    23.  
    24. //地址早绑定  在编辑阶段确定函数地址
    25. //如果想执行让猫说话,那么这个函数地址就不能提前绑定,需要在运行阶段进行绑定,地址晚绑定
    26. void speak(Animal &animal) // Animal & animal = cat;
    27. {
    28.     animal.speak();
    29. }
    30. int main()
    31. {
    32.     Cat cat;
    33.     speak(cat); //输出的cat在说话
    34.     return 0;
    35. }
    36. cat在说话

    多态满足条件

    1 有继承关系

    2 子类要重写父类的虚函数

    动态多态的使用

    父类的指针或引用指向子类对象

     多态的原理：

    1. #include "iostream"
    2.  
    3. using namespace std;
    4. class Animal {
    5. public:
    6.      virtual void speak(){
    7.         cout << "动物在说话" << endl;
    8.     }
    9. };
    10. class Animal2 {
    11. public:
    12.     void speak(){
    13.         cout << "动物在说话" << endl;
    14.     }
    15. };
    16. void test1(){
    17.     //空对象的大小为1
    18.     cout << "sizeof Animal2:"<<sizeof(Animal2) << endl;
    19.     //64位系统下，虚函数占8个字节，也就是一个指针的大小
    20.     cout << "sizeof Animal:"<<sizeof(Animal) << endl;
    21. }
    22. int main() {
    23.     test1();
    24.     return 0;
    25. }
    26. sizeof Animal:8
    27. sizeof Animal2:1

    空对象内存分布：

     

     

    1. #include "iostream"
    2.  
    3. using namespace std;
    4. class Animal {
    5. public:
    6.      virtual void speak(){
    7.         cout << "动物在说话" << endl;
    8.     }
    9. };
    10. class Cat: public Animal {
    11. public:
    12.     virtual void speak(){
    13.         cout << "小猫在说话" << endl;
    14.     }
    15. };
    16. void speak(Animal & animal){
    17.     animal.speak();
    18. }
    19. void test1(){
    20.     Cat cat;
    21.     speak(cat);
    22. }
    23. int main() {
    24.     test1();
    25.     return 0;
    26. }
    27. 小猫在说话

    原理：

    由于Animal些了个虚函数，类结构发生了改变，多了一个指针，这个指针叫做虚函数表指针，虚函数表的内部记录了虚函数的入口地址，当子类重写了这个虚函数的时候，会把自身虚函数表中的函数给替换掉，替换为子类的函数，所以当你用父类的引用指向子类对象的时候，由于你本身是一个子类对象，所以当你去调用speak时，会在子类去找真正的函数地址。

    Cat没发生重写时Cat的内存分布：

     

    多态案例：

    开闭原则：对修改进行关闭，对扩展进行开放

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. class AbstractCalculator {
    6. public:
    7.     virtual int getResult() = 0;
    8.  
    9.     int m_Num1;
    10.     int m_Num2;
    11. };
    12.  
    13. class AddCalculator : public AbstractCalculator {
    14. public:
    15.     virtual int getResult() {
    16.         return m_Num1 + m_Num2;
    17.     }
    18. };
    19.  
    20. class SubCalculator : public AbstractCalculator {
    21. public:
    22.     virtual int getResult() {
    23.         return m_Num1 - m_Num2;
    24.     }
    25. };
    26.  
    27. class MulCalculator : public AbstractCalculator {
    28. public:
    29.     virtual int getResult() {
    30.         return m_Num1 * m_Num2;
    31.     }
    32. };
    33.  
    34. void test() {
    35. //多态使用：父类指针或者引用指向子类对象
    36.     AbstractCalculator *ac = new MulCalculator;
    37.     ac->m_Num1 = 10;
    38.     ac->m_Num2 = 20;
    39.     cout << ac->getResult() << endl;
    40.     //开辟在堆区，用完记得销毁
    41.     delete ac;
    42. }
    43.  
    44. int main() {
    45.     test();
    46.     return 0;
    47. }

    总结：多态的优点：

    代码组织结构清晰

    可读性强

    利于前期和后期的扩展以及维护

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. //纯虚函数和抽象类
    6. class Base {
    7. public:
    8.     //纯虚函数
    9.     //只要有一个纯虚函数，这个类就称为抽象类
    10.     //抽象类特点：
    11.     //1 无法实例化对象
    12.     //2 抽象类的子类，必须重写父类中的纯虚函数，否则也属于抽象类
    13.     virtual void func() = 0;
    14. };
    15.  
    16. class Son : public Base {
    17. public:
    18.     void func() {
    19.         cout << "son func函数调用" << endl;
    20.     }
    21. };
    22.  
    23. class Son2 : public Base {
    24. public:
    25.     void func() {
    26.         cout << "son2 func函数调用" << endl;
    27.     }
    28. };
    29.  
    30. void test() {
    31. //    Base b;//抽象类时无法实例化对象
    32. //    new Base;//抽象类时无法实例化对象
    33.  
    34. //Son s;//子类必须重写父类中的纯虚函数，否则无法实例化对象
    35.  
    36.     Base *base = new Son;
    37.     base->func();
    38.     Base *base2 = new Son2;
    39.     base2->func();
    40. }
    41.  
    42. int main() {
    43.     test();
    44.     return 0;
    45. }
    46. son func函数调用
    47. son2 func函数调用

     

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. //多态案例2 制作饮品
    6. class AbstractDrink {
    7. public:
    8.     //煮水
    9.     virtual void Boil() = 0;
    10.  
    11.     //冲泡
    12.     virtual void Brew() = 0;
    13.  
    14.     //倒入杯中
    15.     virtual void PourInCup() = 0;
    16.  
    17.     //加入辅料
    18.     virtual void PutSomething() = 0;
    19.  
    20.     //制作饮品
    21.     void makeDrink() {
    22.         Boil();
    23.         Brew();
    24.         PourInCup();
    25.         PutSomething();
    26.     }
    27. };
    28.  
    29. class Coffee : public AbstractDrink {
    30. public:
    31.     //煮水
    32.     virtual void Boil() {
    33.         cout << "咖啡煮水" << endl;
    34.     }
    35.  
    36.     //冲泡
    37.     virtual void Brew() {
    38.         cout << "咖啡冲泡" << endl;
    39.     }
    40.  
    41.     //倒入杯中
    42.     virtual void PourInCup() {
    43.         cout << "咖啡倒入杯中" << endl;
    44.     };
    45.  
    46.     //加入辅料
    47.     virtual void PutSomething() {
    48.         cout << "咖啡加入辅料" << endl;
    49.     }
    50. };
    51.  
    52. class Tea : public AbstractDrink {
    53. public:
    54.     //煮水
    55.     virtual void Boil() {
    56.         cout << "茶叶煮水" << endl;
    57.     }
    58.  
    59.     //冲泡
    60.     virtual void Brew() {
    61.         cout << "茶叶冲泡" << endl;
    62.     }
    63.  
    64.     //倒入杯中
    65.     virtual void PourInCup() {
    66.         cout << "茶叶倒入杯中" << endl;
    67.     };
    68.  
    69.     //加入辅料
    70.     virtual void PutSomething() {
    71.         cout << "茶叶加入辅料" << endl;
    72.     }
    73. };
    74.  
    75. void doWork(AbstractDrink *ad) {
    76.     ad->makeDrink();
    77.     delete ad;//释放
    78. }
    79.  
    80. int main() {
    81.     doWork(new Coffee);
    82.     cout << "------------------------" << endl;
    83.     doWork(new Tea);
    84.     return 0;
    85. }
    86. 咖啡煮水
    87. 咖啡冲泡
    88. 咖啡倒入杯中
    89. 咖啡加入辅料
    90. ------------------------
    91. 茶叶煮水
    92. 茶叶冲泡
    93. 茶叶倒入杯中
    94. 茶叶加入辅料

     

    虚析构和纯虚析构

    下面有问题的代码：

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. //虚析构和纯虚析构
    6. class Animal {
    7. public:
    8.     Animal() {
    9.         cout << "Animal构造函数调用" << endl;
    10.     }
    11.  
    12.     ~Animal() {
    13.         cout << "Animal的析构函数调用" << endl;
    14.     }
    15.  
    16.     //纯虚函数
    17.     virtual void speak() = 0;
    18. };
    19.  
    20. class Cat : public Animal {
    21. public:
    22.     Cat(string name) {
    23.         cout << "Cat的构造函数调用" << endl;
    24.         m_Name = new string(name);
    25.     }
    26.  
    27.     ~Cat() {
    28.         if (m_Name != nullptr) {
    29.             cout << "Cat析构函数调用" << endl;
    30.             delete m_Name;
    31.             m_Name = nullptr;
    32.         }
    33.     }
    34.  
    35.     virtual void speak() {
    36.         cout << *m_Name << "小猫在说话" << endl;
    37.     }
    38.  
    39.     string *m_Name;
    40. };
    41.  
    42. void test1() {
    43.     Animal *animal = new Cat("Tom");
    44.     animal->speak();
    45.     //父类指针在析构的时候，不会调用子类中析构函数，
    46.     //导致子类如果有堆区的属性，会出现内存泄漏
    47.     delete animal;
    48. }
    49.  
    50. int main() {
    51.     test1();
    52.     return 0;
    53. }
    54. Animal构造函数调用
    55. Cat的构造函数调用
    56. Tom小猫在说话
    57. Animal的析构函数调用

    上面没有输出Cat的析构函数

    解决上面的办法也很简单，就是把父类Animal的析构函数改为虚析构函数

    代码如下：

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. //虚析构和纯虚析构
    6. class Animal {
    7. public:
    8.     Animal() {
    9.         cout << "Animal构造函数调用" << endl;
    10.     }
    11.  
    12.     //利用虚析构可以解决 父类指针释放子类对象时不干净的问题
    13.     virtual ~Animal() {
    14.         cout << "Animal的析构函数调用" << endl;
    15.     }
    16.  
    17.     //纯虚函数
    18.     virtual void speak() = 0;
    19. };
    20.  
    21. class Cat : public Animal {
    22. public:
    23.     Cat(string name) {
    24.         cout << "Cat的构造函数调用" << endl;
    25.         m_Name = new string(name);
    26.     }
    27.  
    28.     ~Cat() {
    29.         if (m_Name != nullptr) {
    30.             cout << "Cat析构函数调用" << endl;
    31.             delete m_Name;
    32.             m_Name = nullptr;
    33.         }
    34.     }
    35.  
    36.     virtual void speak() {
    37.         cout << *m_Name << "小猫在说话" << endl;
    38.     }
    39.  
    40.     string *m_Name;
    41. };
    42.  
    43. void test1() {
    44.     Animal *animal = new Cat("Tom");
    45.     animal->speak();
    46.     //父类指针在析构的时候，不会调用子类中析构函数，
    47.     // 导致子类如果有堆区的属性，会出现内存泄漏
    48.     delete animal;
    49. }
    50.  
    51. int main() {
    52.     test1();
    53.     return 0;
    54. }
    55. Animal构造函数调用
    56. Cat的构造函数调用
    57. Tom小猫在说话
    58. Cat析构函数调用
    59. Animal的析构函数调用

    纯虚析构，直接执行会报错，大概提示就是无法解析的外部命令

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. //虚析构和纯虚析构
    6. class Animal {
    7. public:
    8.     Animal() {
    9.         cout << "Animal构造函数调用" << endl;
    10.     }
    11.  
    12.     //利用虚析构可以解决 父类指针释放子类对象时不干净的问题
    13. //    virtual ~Animal() {
    14. //        cout << "Animal的析构函数调用" << endl;
    15. //    }
    16.     //纯虚析构
    17.     virtual  ~Animal() = 0;
    18.  
    19.     //纯虚函数
    20.     virtual void speak() = 0;
    21. };
    22.  
    23. class Cat : public Animal {
    24. public:
    25.     Cat(string name) {
    26.         cout << "Cat的构造函数调用" << endl;
    27.         m_Name = new string(name);
    28.     }
    29.  
    30.     ~Cat() {
    31.         if (m_Name != nullptr) {
    32.             cout << "Cat析构函数调用" << endl;
    33.             delete m_Name;
    34.             m_Name = nullptr;
    35.         }
    36.     }
    37.  
    38.     virtual void speak() {
    39.         cout << *m_Name << "小猫在说话" << endl;
    40.     }
    41.  
    42.     string *m_Name;
    43. };
    44.  
    45. void test1() {
    46.     Animal *animal = new Cat("Tom");
    47.     animal->speak();
    48.     //父类指针在析构的时候，不会调用子类中析构函数，
    49.     // 导致子类如果有堆区的属性，会出现内存泄漏
    50.     delete animal;
    51. }
    52.  
    53. int main() {
    54.     test1();
    55.     return 0;
    56. }

    虚析构的时候，是有函数的实现的，

    但是上面的纯虚析构没有实现，比如父类中也有一些数据开辟到了堆区，析构函数实现就有用了，父类堆区实现在父类析构函数中实现。

    解决方案，在类外实现析构函数

    1. Animal::~Animal() {
    2.     cout << "Animal纯虚析构函数调用" << endl;
    3. }
    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. //虚析构和纯虚析构
    6. class Animal {
    7. public:
    8.     Animal() {
    9.         cout << "Animal构造函数调用" << endl;
    10.     }
    11.  
    12.     //利用虚析构可以解决 父类指针释放子类对象时不干净的问题
    13. //    virtual ~Animal() {
    14. //        cout << "Animal的析构函数调用" << endl;
    15. //    }
    16.     //纯虚析构 需要声明，也需要实现（类外实现）
    17.     //有了纯虚析构之后，这个类属于抽象类，无法实例化
    18.     virtual  ~Animal() = 0;
    19.  
    20.     //纯虚函数
    21.     virtual void speak() = 0;
    22. };
    23.  
    24. Animal::~Animal() {
    25.     cout << "Animal纯虚析构函数调用" << endl;
    26. }
    27.  
    28. class Cat : public Animal {
    29. public:
    30.     Cat(string name) {
    31.         cout << "Cat的构造函数调用" << endl;
    32.         m_Name = new string(name);
    33.     }
    34.  
    35.     ~Cat() {
    36.         if (m_Name != nullptr) {
    37.             cout << "Cat析构函数调用" << endl;
    38.             delete m_Name;
    39.             m_Name = nullptr;
    40.         }
    41.     }
    42.  
    43.     virtual void speak() {
    44.         cout << *m_Name << "小猫在说话" << endl;
    45.     }
    46.  
    47.     string *m_Name;
    48. };
    49.  
    50. void test1() {
    51.     Animal *animal = new Cat("Tom");
    52.     animal->speak();
    53.     //父类指针在析构的时候，不会调用子类中析构函数，
    54.     // 导致子类如果有堆区的属性，会出现内存泄漏
    55.     delete animal;
    56. }
    57.  
    58. int main() {
    59.     test1();
    60.     return 0;
    61. }
    62. Animal构造函数调用
    63. Cat的构造函数调用
    64. Tom小猫在说话
    65. Cat析构函数调用
    66. Animal纯虚析构函数调用

    多态案例3 电脑组装

    1. #include "iostream"
    2.  
    3. using namespace std;
    4.  
    5. class CPU {
    6. public:
    7.     virtual void calculator() = 0;
    8. };
    9.  
    10. class VideoCard {
    11. public:
    12.     virtual void display() = 0;
    13. };
    14.  
    15. class Memory {
    16. public:
    17.     virtual void storage() = 0;
    18. };
    19.  
    20. class Computer {
    21. public:
    22.     Computer(CPU *cpu, VideoCard *vCard, Memory *mem) {
    23.         m_cpu = cpu;
    24.         m_vCard = vCard;
    25.         m_mem = mem;
    26.     }
    27.  
    28.     void work() {
    29.         m_cpu->calculator();
    30.         m_vCard->display();
    31.         m_mem->storage();
    32.     }
    33.  
    34.     //提供析构函数来释放3个零件
    35.     ~Computer() {
    36.         if (m_cpu != nullptr) {
    37.             delete m_cpu;
    38.             m_cpu = nullptr;
    39.         }
    40.         if (m_vCard != nullptr) {
    41.             delete m_vCard;
    42.             m_vCard = nullptr;
    43.         }
    44.         if (m_mem != nullptr) {
    45.             delete m_mem;
    46.             m_mem = nullptr;
    47.         }
    48.     }
    49.  
    50. private:
    51.     CPU *m_cpu;
    52.     VideoCard *m_vCard;
    53.     Memory *m_mem;
    54. };
    55.  
    56. //具体厂商 Intel
    57. class IntelCPU : public CPU {
    58. public:
    59.     virtual void calculator() {
    60.         cout << "Intel CPU" << endl;
    61.     }
    62. };
    63.  
    64. class IntelVideoCard : public VideoCard {
    65. public:
    66.     virtual void display() {
    67.         cout << "Intel VideoCard" << endl;
    68.     }
    69.  
    70. };
    71.  
    72. class IntelMemory : public Memory {
    73. public:
    74.     virtual void storage() {
    75.         cout << "Intel Memory" << endl;
    76.     }
    77. };
    78.  
    79. //具体厂商 Lenovo
    80. class LenovoCPU : public CPU {
    81. public:
    82.     virtual void calculator() {
    83.         cout << "Lenovo CPU" << endl;
    84.     }
    85. };
    86.  
    87. class LenovoVideoCard : public VideoCard {
    88. public:
    89.     virtual void display() {
    90.         cout << "Lenovo VideoCard" << endl;
    91.     }
    92.  
    93. };
    94.  
    95. class LenovoMemory : public Memory {
    96. public:
    97.     virtual void storage() {
    98.         cout << "Lenovo Memory" << endl;
    99.     }
    100. };
    101.  
    102. void test() {
    103.     //创建第一台电脑
    104.     Computer *computer = new Computer(new LenovoCPU, new IntelVideoCard, new IntelMemory);
    105.     computer->work();
    106.     cout << "------------------" << endl;
    107.     //创建第二台电脑
    108.     CPU *cpu2 = new IntelCPU;
    109.     VideoCard *vc2 = new IntelVideoCard;
    110.     Memory *mem2 = new LenovoMemory;
    111.     Computer *computer2 = new Computer(cpu2, vc2, mem2);
    112.     computer2->work();
    113. }
    114.  
    115. int main() {
    116.     test();
    117.     return 0;
    118. }
    119.  
    120. Lenovo CPU
    121. Intel VideoCard
    122. Intel Memory
    123. ------------------
    124. Intel CPU
    125. Intel VideoCard
    126. Lenovo Memory

  • 相关阅读:
    python 文本文件的编码格式：ASCII编码和UNICODE编码
    排序算法——希尔排序
    递推算法刷题
    树莓派4B（Ubuntu20.04）使用LCD1602液晶屏开机自动显示IP及其他信息
    Java 中的全部锁
    如何为 Python 应用选择最好的 Docker 镜像？
    Java 方法中循环调用具有事务的方法
    如何读懂火焰图？+ 实例讲解程序性能优化
    【驱动开发】LED灯的亮灭——通过字符设备驱动的分步实现编写LED驱动，实现设备文件和设备的绑定
    大数据打造六维车险评估体系，律商风险再出发
  • 原文地址：https://blog.csdn.net/wade1010/article/details/128191902