目录
1.多态的基本概念
2.多态案例一 计算机类
3. 纯虚函数和抽象类
4 多态案例二——制作饮品
5 虚析构和纯虚析构
6 多态案例三——电脑组装
1.多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类
○静态多态：函数重载 和 运算符重载属于静态多态，复用函数名
○动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态区别：
○静态多态的函数地址早绑定 - 编译阶段确定函数地址
○动态多态的函数地址晚绑定 - 运行阶段确定函数地址
下面通过案例进行讲解多态
#includeusing namespace std; //多态 //动物类 class Animal { public: virtual void speak() { cout << "Animal is speaking" << endl; } }; //猫类 class Cat : public Animal { public: //重写 函数返回值类型 函数名 参数列表 完全相同 void speak() { cout << "cat is speaking" << endl; } }; //狗类 class Dog : public Animal { public: void speak() { cout << "dog is speaking" << endl; } }; //执行说话的函数 //地址早绑定 在编译阶段确定函数地址 //如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定 //动态多态满足条件 //1、有继承关系 //2、子类重写父类的虚函数 //动态多态使用 //父类的指针或者引用 执行子类对象 void doSpeak(Animal &animal) // Animal & animal = cat; { animal.speak(); } void test01() { Cat cat; doSpeak(cat); Dog dog; doSpeak(dog); } int main(){ test01(); system("pause"); return 0; }
总结：
多态满足条件
○有继承关系
○子类重写父类中的虚函数
多态使用条件
○父类指针或引用指向子类对象
重写：函数返回值类型 函数名 参数列表 完全一致成为重写
2.多态案例一 计算机类
案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算机类
多态的优点：
○代码组织结构清晰
○可读性强
○利于前期和后期的扩展以及维护
#includeusing namespace std; #include //分别利用普通写法和多态技术实现计算器 //普通写法 class Calculator { public: int getResult(string oper) { if (oper == "+") { return m_Num1 + m_Num2; } else if (oper == "-") { return m_Num1 - m_Num2; } else if (oper == "*") { return m_Num1 * m_Num2; } //如果想扩展新的功能，需要修改源码 //在真实开发中 提倡 开闭原则 //开闭原则：对扩展进行开发，对修改进行关闭 } int m_Num1; //操作数1 int m_Num2; //操作数2 }; void test01() { //创建计算器对象 Calculator c; c.m_Num1 = 10; c.m_Num2 = 10; cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl; cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl; cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl; } //利用多态实现计算机 //多态好处： //1、组织结构清晰 //2、可读性强 //3、对于前期和后期扩展以及维护性高 //实现计算器抽象类 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; //用完后记得销毁 销毁只是销毁堆区的数据，abc本质上还是父类的指针 delete abc; //减法运算 abc = new SubCalculator; abc->m_Num1 = 100; abc->m_Num2 = 10; cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl; delete abc; //乘法运算 abc = new MulCalculator; abc->m_Num1 = 100; abc->m_Num2 = 10; cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl; delete abc; } int main(){ // test01(); test02(); system("pause"); return 0; }
总结：C++开发提倡利用多态设计程序架构，因为多态优点很多
3. 纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数岗位纯虚函数
纯虚函数语法： virtual 返回值类型 函数名 (参数列表) = 0;
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点：
○无法实例化对象
○子类必须重写抽象类中的纯虚函数，否则也属于抽象类
#includeusing namespace std; //纯虚函数和抽象类 class Base { public: //纯虚函数 //只要有一个纯虚函数，这个类称为抽象类 //抽象类特点： //1、无法实例化对象 //2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类 virtual void func() = 0; }; class Son : public Base { public: virtual void func() { cout << "function call" << endl; }; }; void test01() { //invalid new-expression of abstract class type 'Base' // Base b; //抽象类是无法实例化对象 // new Base; //抽象类是无法实例化对象 //Son s; Base *base = new Son; base->func(); } int main(){ test01(); system("pause"); return 0; }
4 多态案例二——制作饮品
案例描述：
制作饮品的大致流程为：煮水 —— 冲泡 —— 倒入杯中 —— 加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
#includeusing namespace std; //多态案例2 制作饮品 class AbstractDrinking { public: //煮水 virtual void Boil() = 0; //冲泡 virtual void Brew() = 0; //倒入杯中 virtual void PourInCup() = 0; //加入辅料 virtual void PutSomething() = 0; //制作饮料 void makerDrink() { Boil(); Brew(); PourInCup(); PutSomething(); } }; //制作咖啡 class Coffee : public AbstractDrinking { //煮水 virtual void Boil() { cout << "boil water" << endl; } //冲泡 virtual void Brew() { cout << "Brew coffee" << endl; } //倒入杯中 virtual void PourInCup() { cout << "pour in cup" << endl; } //加入辅料 virtual void PutSomething() { cout << "put sugar and milk into cup" << endl; } }; //制作茶 class Tea : public AbstractDrinking { //煮水 virtual void Boil() { cout << "boil water" << endl; } //冲泡 virtual void Brew() { cout << "Brew tea" << endl; } //倒入杯中 virtual void PourInCup() { cout << "pour in cup" << endl; } //加入辅料 virtual void PutSomething() { cout << "put lemon into cup" << endl; } }; //制作函数 void doWork(AbstractDrinking * abs)//AbstractDrinking * abs = new coffee { abs->makerDrink(); delete abs; //release } void test01() { //make coffee doWork(new Coffee); cout << "-------------" << endl; //make tea doWork(new Tea); } int main(){ test01(); system("pause"); return 0; }
5 虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
○可以解决父类指针释放子类对象
○都需要有具体的函数实现
虚析构和纯虚析构区别：
○如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法：
virtual ~类名(){}
纯虚析构语法：
virtual ~类名() = 0;
类名::~类名(){}
#includeusing namespace std; #include //虚析构和纯虚析构 class Animal { public: Animal() { cout << "Animal construct function is called" << endl; } //虚析构 // virtual ~Animal() // { // cout << "Animal xigou function is called" << endl; // } //纯虚析构 需要声明也需要实现 //有了纯虚析构之后，这个类也属于抽象类，无法实例化对象 virtual ~Animal() = 0; //纯虚函数 virtual void speak() = 0; }; Animal:: ~Animal() { cout << "Animal pure virtual xigou function is called" << endl; } class Cat:public Animal { public: Cat(string name) { cout << "cat construct function is called" << endl; m_Name = new string(name); } virtual void speak() { cout << *m_Name << " cat is talking" << endl; } ~Cat() { if (m_Name != NULL) { cout << "xigou function is called" << endl; delete m_Name; m_Name = NULL; } } string *m_Name; }; void test01() { Animal *animal = new Cat("Tom"); animal->speak(); //父类指针在析构时候 不会调用子类中析构函数，导致子类中如果有堆区属性，出现内存泄露 delete animal; } int main(){ test01(); system("pause"); return 0; }
总结：
1.虚析构或纯虚析构就是用来解决父类指针释放子类对象
2.如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3.拥有纯虚析构函数的类也属于抽象类
6 多态案例三——电脑组装
案例描述：
电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装成抽象基类，并且提供不同的厂商生产不同的零件，例如intel和Lenovo
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作。
#includeusing 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's CPU is calculating" << endl; } }; //Intel厂商 class IntelVideoCard : public VideoCard { public: virtual void display() { cout << "Intel's VideoCard is displaying" << endl; } }; //Intel厂商 class IntelMemory : public Memory { public: virtual void storage() { cout << "Intel's Memory is storaging" << endl; } }; //Lenovo厂商 class LenovoCPU : public CPU { public: virtual void calculate() { cout << "Lenovo's CPU is calculating" << endl; } }; //Lenovo厂商 class LenovoVideoCard : public VideoCard { public: virtual void display() { cout << "Lenovo's VideoCard is displaying" << endl; } }; //Lenovo厂商 class LenovoMemory : public Memory { public: virtual void storage() { cout << "Lenovo's Memory is storaging" << endl; } }; void test01() { //第一台电脑零件 CPU *intelCpu = new IntelCPU; VideoCard *intelCard = new IntelVideoCard; Memory *intelMem = new IntelMemory; cout << "the first computer is working" << endl; //创建第一台电脑 Computer *computer1 = new Computer(intelCpu,intelCard,intelMem); computer1->work(); delete computer1; cout << "-------------------------------" << endl; cout << "the second computer is working" << endl; //创建第二台电脑 Computer *computer2 = new Computer(new LenovoCPU,new LenovoVideoCard,new LenovoMemory); computer2->work(); delete computer2; cout << "-------------------------------" << endl; cout << "the third computer is working" << endl; //创建第三台电脑 Computer *computer3 = new Computer(new IntelCPU,new LenovoVideoCard,new IntelMemory); computer3->work(); delete computer3; } int main(){ test01(); system("pause"); return 0; }
