多态
导航:
1.多态基本概念
2.多态小案例
3.纯虚函数
4.虚析构与纯虚析构
———————————————————————————————————
多态的基本概念
多态分为两类：
1.静态多态：函数重载以及运算符重载都属于静态多态，复用函数名
2.动态多态：派生类和虚函数实现运行多态
如何区分:
静态多态的函数地址早绑定——编译阶段确定函数地址
动态多态的函数地址晚绑定——运行阶段确定函数地址
动态多态的满足条件:
1.具有继承关系。
2.子类重写父类的虚函数。(虚函数就是在成员函数前加上关键字virtual)
其中重写条件:类中函数的返回值类型，函数名，参数列表必须完全相同
动态多态的使用方法:父类的指针或者引用指向子类地址。
例子:
#include <iostream> #include <string> using namespace std; class cost //定义一个父类 { public: void shop() //仅仅只是一个成员函数，函数地址早绑定，也就是早确定函数地址 { cout<<"最高消费0元"<<endl; } }; class shoper1:public cost //定义一个子类 { public: void shop() { cout<<"最高消费1000元"<<endl; } }; class shoper2:public cost { public: void shop() { cout<<"最高消费1500元"<<endl; } }; void doshop(cost &cs) //父类的指针或者引用可以指向子类对象 { cs .shop(); //进行成员函数调用 } void test01() { shoper1 s1; doshop(s1); //进行引用传递 shoper2 s2; doshop(s2); } int main() { test01(); system("pause"); return 0; }
运行程序:
最高消费0元 最高消费0元
如何将其重写，然后输出该有结果
这时候就要在父类中的函数前加上virtual，此时便为虚函数，是动态多类，函数地址晚绑定，就可以就行重写。
例如:
public: virtual void shop() //加上virtual则叫做虚函数，这样函数地址是晚绑定，不加则就是早绑定，确定了函数地址 { cout<<"最高消费0元"<<endl; } };
这个时候再运行程序:
最高消费1000元 最高消费1500元
———————————————————————————————————
类中仅有一个函数，那么就是一个空类，占1个字节
若类中有一个虚函数，那么占4个字节
虚函数-vfptr (虚函数表指针)指向vftable-(虚函数表)
当子类重写父类的虚函数
子类的虚函数表内部会替换成子类虚函数地址
利用普通和多态写的案例:
#include <iostream> #include <string> using namespace std; //普通写法 class Calculator { public: int getresult(string oper) { if(oper == "+") { return num1+num2; } if(oper == "-") { return num1-num2; } if(oper == "*") { return num1*num2; } return 0; } int num1; int num2; }; //普通的进行测试 void test() { Calculator c1; c1.num1 = 100; c1.num2 = 100; cout<<c1.num1<<"+"<<c1.num2<<"="<<c1.getresult("+")<<endl; cout<<c1.num1<<"-"<<c1.num2<<"="<<c1.getresult("-")<<endl; cout<<c1.num1<<"*"<<c1.num2<<"="<<c1.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 *abs = new AddCalculator;//父类指针或者引用指向子类对象 abs->num1 = 100; abs->num2 = 100; cout<<abs->num1<<"+"<<abs->num2<<"="<<abs->getresult()<<endl; delete abs; //手动进行释放 //调用减法 abs = new SubCalculator; abs->num1 = 100; abs->num2 = 100; cout<<abs->num1<<"-"<<abs->num2<<"="<<abs->getresult()<<endl; delete abs; //调用乘法 abs = new MulCalculator; abs->num1 = 100; abs->num2 = 100; cout<<abs->num1<<"-"<<abs->num2<<"="<<abs->getresult()<<endl; delete abs; } int main() { test02(); system("pause"); return 0; }
用多态写的好处是:有利于扩展，结构清晰，可读性强
———————————————————————————————————
纯虚函数
语法:virtual 返回值类型 函数名 (参数列表) = 0
若父类中含有一个纯虚函数，那么称为抽象类，无法进行实例化
同时子类中也无法实例化对象，也被称为抽象类
例子:
#include <iostream> #include <string> using namespace std; class Base { public: //纯虚函数 virtual void func() = 0; }; class son:public Base { public: virtual void func() { cout<<"子类中func的调用"<<endl; } }; void test() { //Base b1; //其中有纯虚函数，无法实例化 //new Base; //也无法实例化 Base *b = new son; b->func(); delete b; //手动释放 } int main() { test(); system("pause"); return 0; }
———————————————————————————————————虚析构与纯虚析构
共同点:
1.可以解决父类指针释放子类对象
2.都需要有具体的函数实现
区别:
如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构：virtual ~类名() {}
纯虚析构: virtual ~类名() = 0 （需要声明，也要有代码的实现）
能用到纯析构，是因为要在堆区开辟新数据，父类指针释放子类对象
例子:
#include <iostream> #include <string> using namespace std; //纯析构和纯虚函数 class Animal { public: Animal() { cout<<"Aniaml构造函数调用"<<endl; } //纯虚函数 virtual void speak() = 0; //利用虚析构可以解决 父类指针释放子类对象时不干净问题 //纯虚析构 必须要有代码实现 需要声明也需要实现 //有纯虚析构 也无法进行实例化对象 virtual ~Animal() = 0; //虚析构 /*virtual ~Animal() { cout<<"Aniaml析构函数调用"<<endl; }*/ }; //类外进行代码实现 Animal::~Animal() { cout<<"Aniaml纯析构函数调用"<<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() { if(m_Name != NULL) { cout<<"Cat虚构函数调用"<<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.拥有纯虚析构函数的类也属于抽象类，无法进行实例化
