C++初步之核心编程篇五：多态与虚函数类

文章目录

C++初步之核心编程篇五：多态与虚函数类
- 1. 多态的概要
- 2. 多态案例一-计算器类
- 3. 纯虚函数和抽象类
- 4. 多态案例二-制作饮品
- 5. 虚析构和纯虚析构
- 6. 多态案例三-电脑组装

1. 多态的概要

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

下面的实例中，基类 Shape 被派生为两个类，如下所示：

#include <iostream>
using namespace std;class Shape {protected:int width, height;public:Shape( int a=0, int b=0){width = a;height = b;}int area(){cout << "Parent class area :" <<endl;return 0;}
};
class Rectangle: public Shape{public:Rectangle( int a=0, int b=0):Shape(a, b) { }int area (){ cout << "Rectangle class area :" <<endl;return (width * height); }
};
class Triangle: public Shape{public:Triangle( int a=0, int b=0):Shape(a, b) { }int area (){ cout << "Triangle class area :" <<endl;return (width * height / 2); }
};
// 程序的主函数
int main( )
{Shape *shape;Rectangle rec(10,7);Triangle  tri(10,5);// 存储矩形的地址shape = &rec;// 调用矩形的求面积函数 areashape->area();// 存储三角形的地址shape = &tri;// 调用三角形的求面积函数 areashape->area();return 0;
}

运行结果：

Parent class area :
Parent class area :

导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

class Shape {protected:int width, height;public:Shape( int a=0, int b=0){width = a;height = b;}virtual int area(){cout << "Parent class area :" <<endl;return 0;}
};

运行结果：

Rectangle class area :
Triangle class area :

2. 多态案例一-计算器类

//多态实现
//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
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 test02()
{//创建加法计算器AbstractCalculator *abc = new AddCalculator;abc->m_Num1 = 10;abc->m_Num2 = 10;cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;delete abc;  //用完了记得销毁//创建减法计算器abc = new SubCalculator;abc->m_Num1 = 10;abc->m_Num2 = 10;cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;delete abc;  //创建乘法计算器abc = new MulCalculator;abc->m_Num1 = 10;abc->m_Num2 = 10;cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;delete abc;
}int main() {//test01();test02();system("pause");return 0;
}

3. 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。因此可以将虚函数改为纯虚函数，纯虚函数语法：virtual 返回值类型函数名（参数列表）= 0 ;当类中有了纯虚函数，这个类也称为抽象类

抽象类的特点：

无法实例化对象

子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base
{public://纯虚函数//类中只要有一个纯虚函数就称为抽象类virtual void func() = 0;
};class Son :public Base
{public:virtual void func() {cout << "func调用" << endl;};
};void test01()
{Base * base = NULL;//base = new Base; // 错误，抽象类无法实例化对象base = new Son;base->func();delete base;//记得销毁
}int main() {test01();system("pause");return 0;
}

4. 多态案例二-制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料，利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶。

//抽象制作饮品
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;
}void test01() {DoWork(new Coffee);cout << "--------------" << endl;DoWork(new Tea);
}int main() {test01();system("pause");return 0;
}

5. 虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象

都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

class Animal {public:Animal(){cout << "Animal 构造函数调用！" << endl;}virtual void Speak() = 0;//析构函数加上virtual关键字，变成虚析构函数//virtual ~Animal()//{//  cout << "Animal虚析构函数调用！" << endl;//}virtual ~Animal() = 0;
};Animal::~Animal()
{cout << "Animal 纯虚析构函数调用！" << endl;
}//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。class Cat : public Animal {public:Cat(string name){cout << "Cat构造函数调用！" << endl;m_Name = new string(name);}virtual void Speak(){cout << *m_Name <<  "小猫在说话!" << endl;}~Cat(){cout << "Cat析构函数调用!" << endl;if (this->m_Name != NULL) {delete m_Name;m_Name = NULL;}}public:string *m_Name;
};void test01()
{Animal *animal = new Cat("Tom");animal->Speak();//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏//怎么解决？给基类增加一个虚析构函数//虚析构函数就是用来解决通过父类指针释放子类对象delete animal;
}int main() {test01();system("pause");return 0;
}

虚析构或纯虚析构就是用来解决通过父类指针释放子类对象，如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

6. 多态案例三-电脑组装

案例描述：

电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

#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;}

THE END…