12.C++多态

12.多态和虚函数

目录介绍

• 12.1 多态概念
  • 12.1.1 多态基本概念
  • 12.1.2 多态案例
  • 12.1.3 多态的分类
• 12.2 多态和虚函数
  • 12.2.1 虚函数和抽象类
  • 12.2.2 虚函数VS纯虚函数
  • 12.2.3 虚析构和纯虚析构
• 12.4 动态绑定
  • 12.4.1 理解动态绑定
  • 12.4.2 动态绑定案例
• 12.5 多态应用场景
  • 12.5.1 接口设计
  • 12.5.2 扩展性
  • 12.5.3 代码复用
  • 12.5.4 多态总结
• 12.7 多态综合案例
  • 12.7.1 计算器类
  • 12.7.2 制作饮品
  • 12.7.3 组装电脑

12.1 多态概念

在 C++ 中，多态 是面向对象编程（OOP）的核心特性之一，它允许通过基类的指针或引用调用派生类的重写函数，从而实现“一个接口，多种实现”的效果。

多态性主要通过 虚函数 和 动态绑定 来实现。

12.1.1 多态基本概念

面向对象程序设计语言有封装、继承和多态三种机制，这三种机制能够有效提高程序的可读性、可扩充性和可重用性。

“多态（polymorphism）”指的是同一名字的事物可以完成不同的功能。

多态（polymorphism）：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态可以分为编译时的多态和运行时的多态。

1. 前者主要是指函数的重载（包括运算符的重载）、对重载函数的调用，在编译时就能根据实参确定应该调用哪个函数，因此叫编译时的多态；
2. 后者则和继承、虚函数等概念有关。

12.1.2 多态案例

总结：多态满足条件

• 有继承关系
• 子类重写父类中的虚函数

多态使用条件

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

重写：函数返回值类型 函数名 参数列表 完全一致称为重写

class Animal {
public:
    void eat() {
        cout << "动物在吃东西" << endl;
    }
    //Speak函数就是虚函数
    //函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
    virtual void speak() {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal {
public:
    void eat() {
        cout << "小猫吃鱼" << endl;
    }
    void speak() {
        cout << "小猫在说话" << endl;
    }
};

class Dog : public Animal {
public:
    void eat() {
        cout << "小狗吃屎" << endl;
    }
    void speak() {
        cout << "小狗在说话" << endl;
    }
};

//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编
void DoSpeak(Animal & animal){
    animal.eat();
    animal.speak();
}

int main() {
    Cat cat;
    DoSpeak(cat);

    Dog dog;
    DoSpeak(dog);
    return 0;
}

12.1.3 多态的分类

多态分为两类

1. 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
2. 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

1. 静态多态的函数地址早绑定 - 编译阶段确定函数地址
2. 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

12.2 多态和虚函数

12.2.1 虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;，纯虚函数是通过在声明中使用 "= 0" 来指定的。

如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。

抽象类特点：

1. 无法实例化对象
2. 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base {
public:
    //纯虚函数
    //类中只要有一个纯虚函数就称为抽象类
    //抽象类无法实例化对象
    //子类必须重写父类中的纯虚函数，否则也属于抽象类
    virtual void func() = 0;

    //在基类中声明虚函数：在基类中将要被派生类重写的函数声明为虚函数。使用virtual关键字来标识虚函数。例如：
    virtual void foo() {
        cout << "基类虚函数的实现" << endl;
    }
};

class Son : public Base {
public:
    //下面这个报错
//    virtual void func(){
//        cout << "func调用" << endl;
//    };

    virtual void func() override{
        cout << "func调用" << endl;
    };

    //在派生类中重写虚函数：在派生类中重写基类的虚函数，使用相同的函数签名。使用override关键字来明确表示重写基类的虚函数。例如：
    void foo() override {
        cout << "派生类虚函数的实现" << endl;
    }
};

void test() {
    Base *base = NULL;
    //base = new Base; // 错误，抽象类无法实例化对象
    base = new Son;
    base->func();
    base->foo();
    //delete base;//记得销毁 //报错：delete called on 'Base' that is abstract but has non-virtual destructor
}

int main() {
    test();
    return 0;
}

由此可知：

抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。

12.2.2 虚函数VS纯虚函数

虚函数（Virtual Function）和纯虚函数（Pure Virtual Function）是面向对象编程中的重要概念，用于实现多态性和抽象类。

1. 虚函数是在基类中声明为虚拟的成员函数，它可以在派生类中被重写（覆盖）。通过使用虚函数，可以在运行时根据对象的实际类型来调用相应的函数实现，实现多态性。
2. 纯虚函数是在基类中声明为纯虚拟的成员函数，它没有函数体，只有函数声明，并且使用= 0来指示。纯虚函数在基类中没有默认实现，它的具体实现由派生类提供。纯虚函数用于定义抽象类，它不能被实例化，只能作为基类来派生其他类。

以下是虚函数和纯虚函数的示例：

class Base{
public:
    virtual void virtualFunction() {
        // 虚函数的默认实现
        std::cout << "Base virtual function" << std::endl;
    }
    virtual void pureVirtualFunction() = 0;
};

class Derived : public Base {
public:
    void virtualFunction() override {
        // 重写虚函数
        std::cout << "Derived virtual function" << std::endl;
    }
    void pureVirtualFunction() override {
        // 实现纯虚函数
        std::cout << "Derived pure virtual function" << std::endl;
    }
};

int main() {
    Derived derived;
    derived.pureVirtualFunction();
    derived.virtualFunction();
    //new 创建对象
    Derived *derived2 = new Derived();
    derived2->pureVirtualFunction();
    derived2->virtualFunction();
    return 0;
}

虚函数和纯虚函数都可以通过指针或引用来实现运行时多态性，即在运行时根据对象的实际类型来调用相应的函数实现。

12.2.3 虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别： 如果是纯虚析构，该类属于抽象类，无法实例化对象

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

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

类名::~类名(){}

class Animal {
public:
    Animal() {
        cout << "Animal 构造函数调用！" << endl;
    }

    //纯虚函数
    virtual void speak() = 0;

    //虚函数
    virtual void eat() {
        cout << "Animal 动物吃东西！" << endl;
    }

    //普通函数
    void play() {
        cout << "Animal 动物在玩！" << endl;
    }

    //析构函数加上virtual关键字，变成虚析构函数
    virtual ~Animal() {
        cout << "Animal虚析构函数调用！" << endl;
    }
};

class Cat : public Animal {
public:
    string name1;
    string *name2;
public:
    Cat(string name) {
        cout << "Cat 构造函数调用！" << endl;
        name1 = name;
        name2 = new string(name);
    }

    virtual void speak() {
        cout << name1 << "Cat1 在说话！" << endl;
        cout << *name2 << "Cat2 在说话！" << endl;
    }

    void eat() {
        cout << name1 << "Cat1 在吃东西！" << endl;
        cout << *name2 << "Cat2 在吃东西！" << endl;
    }

    //子类和父类方法名相同，且父类是普通方法。
    void play() {
        cout << name1 << "Cat1 在玩！" << endl;
        cout << *name2 << "Cat2 在玩！" << endl;
    }

    ~Cat() {
        cout << "Cat析构函数调用!" << endl;
        if (this->name2 != NULL) {
            delete name2;
            name2 = NULL;
        }
    }
};

int main() {
    Animal *animal = new Cat("Tom");
    animal->speak();
    animal->eat();
    animal->play();
    //通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
    //怎么解决？给基类增加一个虚析构函数
    //虚析构函数就是用来解决通过父类指针释放子类对象
    delete animal;
    return 0;
}

打印结果如下所示：

Animal 构造函数调用！
Cat 构造函数调用！
TomCat1 在说话！
TomCat2 在说话！
TomCat1 在吃东西！
TomCat2 在吃东西！
Animal 动物在玩！
Cat析构函数调用!
Animal虚析构函数调用！

总结：

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

12.4 动态绑定

12.4.1 理解动态绑定

动态绑定是多态的实现机制，它允许在运行时根据对象的实际类型调用相应的函数。

12.4.2 动态绑定案例

通过利用虚函数实现动态绑定，可以在运行时根据对象的实际类型来调用相应的函数，实现多态的效果。

这提供了更灵活和可扩展的代码结构，使得程序能够适应不同类型的对象并执行相应的操作。

class Shape {
public:
    virtual void draw() {
        // 基类虚函数的默认实现
        cout << "Drawing a shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        // 派生类虚函数的实现
        cout << "Drawing a circle." << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        // 派生类虚函数的实现
        cout << "Drawing a rectangle." << endl;
    }
};

int main() {
    Shape *shape;
    Circle circle;
    Rectangle rectangle;

    //示例中，基类Shape中的draw()函数被声明为虚函数。派生类Circle和Rectangle分别重写了基类的虚函数。
    //由于draw()函数是虚函数，因此在运行时会根据实际对象的类型来动态绑定，选择调用相应的派生类的函数实现。

    // 动态绑定，调用Circle类的draw()函数
    shape = &circle;
    shape->draw();

    // 动态绑定，调用Rectangle类的draw()函数
    shape = &rectangle;
    shape->draw();
    return 0;
}

12.5 多态应用场景

• 接口设计：通过基类定义接口，派生类实现具体功能。
• 扩展性：在不修改现有代码的情况下，通过添加新的派生类来扩展功能。
• 代码复用：通过基类复用通用逻辑，派生类只需实现特定功能。

12.5.1 接口设计

12.5.2 扩展性

12.5.3 代码复用

12.5.4 多态总结

• 多态 允许通过基类的指针或引用调用派生类的重写函数。
• 虚函数 是实现多态的关键，派生类可以重写虚函数。
• 纯虚函数 和 抽象类 用于定义接口，派生类必须实现纯虚函数。
• 动态绑定 是多态的机制，它在运行时根据对象的实际类型调用相应的函数。

12.7 多态综合案例

12.7.1 计算器类

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

多态的优点：

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

示例：普通写法

class Calculator {
public:
    int getResult(string oper) {
        if (oper == "+") {
            return num1 + num2;
        } else if (oper == "-") {
            return num1 - num2;
        } else if (oper == "*") {
            return num1 * num2;
        }
        //如果要提供新的运算，需要修改源码
        return 0;
    }
public:
    int num1;
    int num2;
};

void test01() {
    //普通实现测试
    Calculator c;
    c.num1 = 10;
    c.num2 = 10;
    cout << c.num1 << " + " << c.num2 << " = " << c.getResult("+") << endl;
    cout << c.num1 << " - " << c.num2 << " = " << c.getResult("-") << endl;
    cout << c.num1 << " * " << c.num2 << " = " << c.getResult("*") << endl;
}

示例：多态技术

//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
class AbstractCalculator {
public :
    virtual int getResult() {
        return 0;
    }

    int num1;
    int num2;
};

//加法计算器
class AddCalculator : public AbstractCalculator {
public:
    int getResult() {
        return num1 + num2;
    }
};

//减法计算器
class SubCalculator : public AbstractCalculator {
public:
    int getResult() {
        return num1 - num2;
    }
};

//乘法计算器
class MulCalculator : public AbstractCalculator {
public:
    int getResult() {
        return num1 * num2;
    }
};

void test02() {
    //创建加法计算器
    AbstractCalculator *abc = new AddCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->num1 << " + " << abc->num2 << " = " << abc->getResult() << endl;
    delete abc;  //用完了记得销毁

    //创建减法计算器
    abc = new SubCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->num1 << " - " << abc->num2 << " = " << abc->getResult() << endl;
    delete abc;

    //创建乘法计算器
    abc = new MulCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->num1 << " * " << abc->num2 << " = " << abc->getResult() << endl;
    delete abc;
}

12.7.2 制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡，茶叶，奶茶等。

//抽象制作饮品
class AbstractDrinking {
public:
    //烧水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //倒入杯中
    virtual void PourInCup() = 0;
    //加入辅料
    virtual void PutSomething() = 0;
    //规定流程
    void MakeDrink() {
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};

//制作咖啡
class Coffee : public AbstractDrinking {
public:
    //烧水
    virtual void Boil() {
        cout << "煮农夫山泉!" << endl;
    }
    //冲泡
    virtual void Brew() {
        cout << "冲泡咖啡!" << endl;
    }
    //倒入杯中
    virtual void PourInCup() {
        cout << "将咖啡倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething() {
        cout << "加入牛奶!" << endl;
    }
};

//制作茶水
class Tea : public AbstractDrinking {
public:
    //烧水
    virtual void Boil() {
        cout << "煮自来水!" << endl;
    }
    //冲泡
    virtual void Brew() {
        cout << "冲泡茶叶!" << endl;
    }
    //倒入杯中
    virtual void PourInCup() {
        cout << "将茶水倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething() {
        cout << "加入枸杞!" << endl;
    }
};

//业务函数
void DoWork(AbstractDrinking *drink) {
    drink->MakeDrink();
    //delete drink; //报错， delete called on 'AbstractDrinking' that is abstract but has non-virtual destructor
}

void test() {
    DoWork(new Coffee);
    cout << "--------------" << endl;
    DoWork(new Tea);
}

int main() {
    test();
    return 0;
}

打印结果如下所示：

煮农夫山泉!
冲泡咖啡!
将咖啡倒入杯中!
加入牛奶!
--------------
煮自来水!
冲泡茶叶!
将茶水倒入杯中!
加入枸杞!

12.7.3 组装电脑

案例描述：

1. 电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
2. 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
3. 创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
4. 测试时组装三台不同的电脑进行工作

#include<iostream>
using namespace std;

//抽象CPU类
class CPU
{
public:
	//抽象的计算函数
	virtual void calculate() = 0;
};

//抽象显卡类
class VideoCard
{
public:
	//抽象的显示函数
	virtual void display() = 0;
};

//抽象内存条类
class Memory
{
public:
	//抽象的存储函数
	virtual void storage() = 0;
};

//电脑类
class Computer
{
public:
	Computer(CPU * cpu, VideoCard * vc, Memory * mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	//提供工作的函数
	void work()
	{
		//让零件工作起来，调用接口
		m_cpu->calculate();

		m_vc->display();

		m_mem->storage();
	}

	//提供析构函数 释放3个电脑零件
	~Computer()
	{

		//释放CPU零件
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}

		//释放显卡零件
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}

		//释放内存条零件
		if (m_mem != NULL)
		{
			delete m_mem;
			m_mem = NULL;
		}
	}

private:

	CPU * m_cpu; //CPU的零件指针
	VideoCard * m_vc; //显卡零件指针
	Memory * m_mem; //内存条零件指针
};

//具体厂商
//Intel厂商
class IntelCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了！" << endl;
	}
};

class IntelVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel的显卡开始显示了！" << endl;
	}
};

class IntelMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Intel的内存条开始存储了！" << endl;
	}
};

//Lenovo厂商
class LenovoCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Lenovo的CPU开始计算了！" << endl;
	}
};

class LenovoVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的显卡开始显示了！" << endl;
	}
};

class LenovoMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Lenovo的内存条开始存储了！" << endl;
	}
};


void test01()
{
	//第一台电脑零件
	CPU * intelCpu = new IntelCPU;
	VideoCard * intelCard = new IntelVideoCard;
	Memory * intelMem = new IntelMemory;

	cout << "第一台电脑开始工作：" << endl;
	//创建第一台电脑
	Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);
	computer1->work();
	delete computer1;

	cout << "-----------------------" << endl;
	cout << "第二台电脑开始工作：" << endl;
	//第二台电脑组装
	Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);;
	computer2->work();
	delete computer2;

	cout << "-----------------------" << endl;
	cout << "第三台电脑开始工作：" << endl;
	//第三台电脑组装
	Computer * computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);;
	computer3->work();
	delete computer3;

}