C++多态详解及代码示例

多态

一、基本定义

顾名思义，多种形态。多态是C++面向对象的三大特性之一（封装、继承和多态）。

多态分为两种：

• 静态多态：函数的重载、运算符的重载
• 动态多态：派生类和虚函数实现运行时多态

区别：

• 静态多态的函数地址是早绑定，也就是在编译阶段就能确定函数的地址
• 动态多态的函数地址是晚绑定，也就是在运行阶段才确定函数的地址

C++中允许父类的引用和指针可以直接指向子类对象。也就是说，如果在需要父类的引用或者指针的时候，都可以使用子类的对象或者指针来代替，然后在子类中实现父类中对应的虚函数，就可以实现运行时多态了。

二、动态多态的条件

1. 有继承关系
2. 子类要重写父类的虚函数（重写：函数的返回值及类型 ，函数声明，参数个数、类型顺序要完全相同）

三、如何使用运行时多态

父类的指针或引用，调用子类重写后的虚函数即可实现多态。

代码示例

#include <iostream>
using namespace std;

// 父类
class Animal{
public:
    virtual void speak() //虚函数
    {
        std::cout << "Animal speaking" << std::endl;
    }
};

class Cat:public Animal{
public:
    virtual void speak() // 子类中的虚函数，virtual关键字可加可不加
    {
        std::cout << " Cat speaking" << std::endl;
    }
};

int main(int argc, char* argv[])
{
	// 通过父类的指针去指向子类的对象
    Animal * a = new Cat;
    // 调用子类重写过的虚函数，实现多态
    a->speak();

    delete a;
	return 0;
}

运行结果：

我们的预期是传入某一类动物就让该类动物叫。上面是早绑定，要想实现需要晚绑定，晚绑定也就是在运行时绑定，很简单，在父类的函数前加virtual关键字。

四、 多态的案例——计算器

4.1 普通写法

缺点：每新增一个功能都需要修改源代码，并加一个else if，不优雅。

#include <iostream>
using namespace std;

class CheapCalculator{

public:
    int getResult(string op)
    {
        if (op == "+")
        {
            return m_A +m_B;
        }
        else if(op == "-")
        {
            return m_A - m_B;
        }
        else{
            //
        }
    }

public:
    int m_A;
    int m_B;
};

int main(int argc, char* argv[])
{
    CheapCalculator cal;
    cal.m_A = 100;
    cal.m_B = 200;

    std::cout << "cal.m_A + cal.m_B = " << cal.getResult("+")<< std::endl;

	return 0；
}

4.2 多态实现：

#include <iostream>

using namespace std;

// 计算器的父类，暴露出一个公共接口，并声明为虚函数
class AbstractCalculator{
public:
    virtual int getResult()
    {
        return 0;
    }
public:
    int m_A;
    int m_B;
};
// 加法计算器继承父类，并重写父类的同名虚函数
class AddCalculator:public AbstractCalculator{
public:
    virtual int getResult()
    {
        return m_A + m_B;
    }
};
// 减法法计算器继承父类，并重写父类的同名虚函数
class SubCalculator:public AbstractCalculator{
public:
    virtual int getResult()
    {
        return m_A - m_B;
    }
};

int main(int argc, char* argv[])
{
    AbstractCalculator* add = new AddCalculator();
    add->m_A = 100;
    add->m_B = 200;

    std::cout << "add: " << add->getResult() << std::endl;

    AbstractCalculator* sub = new SubCalculator();
    sub->m_A = 100;
    sub->m_B = 200;
    std::cout << "sub: " << sub->getResult() << std::endl;
    delete sub; // 释放空间
    
    return 0;
}

优点：

• 开闭原则，对扩展开放，对修改关闭。容易扩展和维护。
• 代码组织结构清晰，可读性强

五、纯虚函数和抽象类

在C++多态中，通常父类的虚函数的实现是毫无意义的，都是在调用子类重写的内容。C++提供了纯虚函数，语法如下：

virtual 返回值类型 函数名(参数列表) = 0;
eg:
virtual int func(int a, string s) = 0;

当类中有了纯虚函数，这个类就被称为抽象类。抽象类顾名思义，就很抽象，我们一般在不知道怎么形容一个事务的时候就说它很抽象。所以抽象类的特点：

• 无法实例化对象，比如：不能实例化一个动物或者一个水果出来；
• 子类必须重写父类的纯虚函数，否则也被称为抽象类

代码示例：

// 抽象类
class Base{
public:
    // 纯虚函数
    virtual void func() = 0;
};

class Son:public Base{
public:
    virtual void func(){
        std::cout <<"Son func() call" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    // Base b; // 抽象类不能实例化
    Son s;
    s.func();  // 这样体现不出多态

    std::cout << "====== 多态调用 =====" << std::endl;
    Base *p = new Son;
    p->func();
	delete p; // 释放空间

	return 0;
}

六、虚析构和纯虚析构

使用多态的时候，如果子类中有属性开辟到了堆区，因为我们都是使用父类指针或者引用去调用。父类的指针是无法调用到子类的析构代码的。也就是说，子类在堆区上申请的空间就不能释放，造成内存泄漏。

解决方案：将父类中的析构函数改写为虚析构或者纯虚析构

#include <iostream>
#include <string>
using namespace std;

class Animal{
public:
    Animal()
    {
        std::cout <<"Animal constructor call" << std::endl;
    }

    // 方案1：父类的析构函数为虚函数，可以解决使用多态时子类堆上创建的属性的释放问题
    // virtual ~Animal(){
    //     std::cout <<"Animal destroy call" << std::endl;
    // }

    // 方案2：父类的析构函数创建为纯析构函数，因为父类中也有可能有堆上创建的属性，所以需要实现该纯虚析构函数
    virtual ~Animal() = 0; 

    virtual void speak()
    {
        std::cout << "Animal speaking" << std::endl;
    }
};

// 纯虚析构函数的实现
Animal::~Animal()
{
    std::cout << "Animal pure destroy call" << std::endl;
}

class Cat:public Animal{
public:
    Cat(string name)
    {
        std::cout <<"Cat constructor call" << std::endl;
        m_Name = new string(name);
    }

    ~Cat()
    {
        if (m_Name)
        {
            std::cout <<"Cat destroy call" << std::endl;
            delete m_Name;
            m_Name = nullptr;
        }
    }
    virtual void speak() // 子类中的虚函数，virtual关键字可加可不加
    {
        std::cout << *m_Name << " Cat speaking" << std::endl;
    }

public:
    string* m_Name; // 子类中堆上创建的属性
};

int main(int argc, char* argv[])
{
    Animal * a = new Cat("Tom");
    a->speak();
    delete a;
    return 0;
}

析构函数为虚函数后的执行效果：
方案1：

方案2：

核心总结

不管我们是使用虚函数还是纯虚函数，要实现多态，子类就必须重写父类的虚函数，并通过父类的指针或者引用去调用子类重写过的方法。

文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习: