C++ 多态

多态

基本概念#

多态是C++面向对象三大特性之一

• 多态分为两类
  • 静态多态：函数重载和运算符重载属于静态多态，复用函数名
  • 动态多态：派生类和虚函数实现运行时多态
  • 静态多态和动态多态区别：
    • 静态多态的函数地址早绑定——编译阶段确定函数地址
    • 动态多态的函数地址晚绑定——运行阶段确定函数地址

 

• 动态多态满足条件
  • 有继承关系
  • 子类重写父类的虚函数（使用virtual修饰）
    • 重写：函数返回值类型 函数名 参数列表完全一致 称为重写
• 动态多态的使用——父类的指针或者引用 执行子类对象

#include "iostream"
using namespace std;
 
class Animal {
public:
    // 虚函数
    virtual void speak() {
        cout << "动物在说话" << endl;
    }
};
 
class Cat : public Animal {
public:
    void speak() {
        cout << "小猫在说话~" << endl;
    }
};
 
void doSpeak(Animal &animal) {
    animal.speak();
}
 
void test02() {
    Cat cat;
    doSpeak(cat);
}
 
int main() {
    cout << "hello!" << endl;
    test02();
}

动态多态原理#

上述代码中，Animal类看起来是一个空类，如果不带virtual关键字，应占1字节，但其实际上占了4字节，其内部是一个vfptr（virtual function pointer 虚函数（表）指针），它指向vftable虚函数表，表内记录了虚函数的地址。

当子类重写父类的虚函数，子类中的虚函数表内部原本父类的虚函数地址会替换成子类的虚函数地址。

当父类的指针或者引用指向子类对象的时候，发生多态

Animal & animal = cat;

animal.speak();

发生多态，调用Cat的speak()函数。

 

优点#

• 代码组织结构清晰
• 可读性强
• 利于前期和后期的扩展及维护

 

• 多态案例——计算器类
  • 分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

#include "iostream"
using namespace std;
 
/*
 * 分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
 */
 
//普通方法
class Calculator {
public:
    float getResult(string op) {
        if(op == "+") {
            return num1 + num2;
        }else if(op == "-") {
            return num1 - num2;
        }else if(op == "*") {
            return num1 * num2;
        }else if(op == "/") {
            return num1 / num2;
        }else {
            cout << "操作符输入有误" << endl;
        }
        // 如果想扩展新功能，需要修改源码
        // 在真实开发中 提倡开闭原则
        // 开闭原则： 对扩展进行开发，对修改进行关闭
    }
    int num1;
    int num2;
};
 
void test11() {
    Calculator c1;
    c1.num1 = 15;
    c1.num2 = 5;
    int result = c1.getResult("/");
    cout << c1.num1 << " + " << c1.num2 << " = " << result << endl;
}
 
//  利用多态实现计算器
// 计算器抽象类
class AbstractCalculator {
public:
    virtual int getResult() {
        return 0;
    }
    int m_Num1;
    int m_Num2;
};
 
//加法计算器
class AddCalculator : public AbstractCalculator {
public:
    int getResult() {
        return m_Num1 + m_Num2;
    }
};
//减法计算器
class SubCalculator : public AbstractCalculator {
public:
    int getResult() {
        return m_Num1 - m_Num2;
    }
};
//乘法计算器
class MulCalculator : public AbstractCalculator {
public:
    int getResult() {
        return m_Num1 * m_Num2;
    }
};
void test22() {
    // 多态使用条件
    // 父类指针或者引用指向子类对象
 
    // 加法运算
    AbstractCalculator *ac = new AddCalculator;
    ac -> m_Num1 = 15;
    ac -> m_Num2 = 5;
    cout << ac -> m_Num1 << "+" << ac -> m_Num2 << "=" << ac -> getResult() << endl;
    // 记得销毁
    delete ac;
    ac = new SubCalculator;
    ac -> m_Num1 = 15;
    ac -> m_Num2 = 5;
    cout << ac -> m_Num1 << "-" << ac -> m_Num2 << "=" << ac -> getResult() << endl;
    delete ac;
    ac = new MulCalculator;
    ac -> m_Num1 = 15;
    ac -> m_Num2 = 5;
    cout << ac -> m_Num1 << "*" << ac -> m_Num2 << "=" << ac -> getResult() << endl;
    delete ac;
}
 
int main() {
    //test11();
    test22();
}

 

虚析构和纯虚函数#

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

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

 

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

 

虚析构和纯虚析构区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象
• 纯虚析构类内声明类外实现

 

虚析构语法：virtual ~类名(){ }

纯虚析构语法：

virtual ~类名() = 0;

类名  : :  ~类名( ) { }

 

总结：

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