C++之多态（纯虚函数、抽象类、虚析构、纯虚析构）
多态的基本概念
多态分两类
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别
静态多态的函数地址 早绑定，编译阶段确定函数地址
动态多态的函数地址 晚绑定，运行阶段确定函数地址
动态多态的满足条件
1、有继承关系
2、子类重写父类的虚函数
动态多态的使用
父类的指针或者引用，执行子类对象
多态的优点
1、代码组织结构清晰
2、可读性强
3、利于前期和后期的扩展和维护
#include
using namespace std;
class Animal
{
public:
//虚函数 动态多态
virtual void speak()
{
cout << "shuohua" << endl;
}
//Animal类内部结构：vfptr：虚函数（表）指针 指向一个虚函数表（vftable）
//虚函数表的内部记录一个虚函数的地址（&Animal::speak）
//而子类也会继承这个指针，指向子类的虚函数表，
//当子类重写了父类的虚函数，那么子类内部的虚函数表会替换(覆盖)成子类的函数地址（&Cat::speak）
//当父类的指针或引用指向子类对象时，发生多态
};
class Cat :public Animal
{
public:
//重写：函数返回值类型 函数名 参数列表 完全相同
virtual void speak()
{
cout << "cat 说话" << endl;
}
};
class Dog :public Animal
{
virtual void speak()
{
cout << "Dog 说话" << endl;
}
};
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
void doSpeak(Animal &animal)//c++允许父子类的相互转换
{
animal.speak();
}
void test02()
{
cout << "size of Animal = " << sizeof(Animal1) << endl;//加virtual后 4字节 无virtual，相当于空类 1字节
}
void test01()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main()
{
test01();
//test02();
system("pause");
return 0;
}
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，那么动态联编
案例
#include
using namespace std;
//普通实现
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;
int m_Num2;
};
//利用多态实现
//基类
class AbstractCalculator
{
public:
virtual int getResult()
{
return 0;
}
int m_Num1;
int m_Num2;
};
class AddCllculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 + m_Num2;
}
};
class SubCllculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 - m_Num2;
}
};
class MulCllculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 * m_Num2;
}
};
void work(AbstractCalculator& calculator)
{
cout << calculator.getResult() << endl;
}
void test01()
{
//用指针指向子类对象
AbstractCalculator* cal = new AddCllculator;
cal->m_Num1 = 10;
cal->m_Num2 = 10;
cout << cal->getResult() << endl;
delete cal; //记得销毁
//用引用指向子类对象
AddCllculator add;
add.m_Num1 = 100;
add.m_Num2 = 100;
work(add);
}
int main()
{
test01();
system("pause");
return 0;
}
纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此，可将虚函数改为纯虚函数
纯虚函数的语法： virtual 返回值类型 函数名 (参数列表) = 0;
抽象类：当类中有了（只要有一个）纯虚函数，这个类也称为抽象类
抽象类的特点：
1、无法实例化对象
2、子类必须重写抽象类中的纯虚函数，否则也属于抽象类
#include
using namespace std;
//抽象类
class Base
{
public:
virtual void func() = 0;//子类必须要重写
};
class Son1 :public Base
{
public:
virtual void func()
{
cout << "Son1 func函数调用" << endl;
}
};
class Son2 :public Base
{
public:
virtual void func()
{
cout << "Son2 func函数调用" << endl;
}
};
void test01()
{
//Base b = new Base 抽象类无法实例化
Son1 s;//子类必须重写父类的纯虚函数，否则也无法实例化
s.func();
Base* base1 = new Son1;
base1->func();
Base* base2 = new Son2;
base2->func();//这就是多态的体现，通过创建对象的不同调用不同的接口
}
int main()
{
test01();
system("pause");
return 0;
}
虚析构和纯虚析构
在使用多态时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
解决方法：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
可以解决父类指针释放子类对象
都需要具体的函数实现
虚构函数和纯虚析构的区别：如果是纯虚析构，该类属于抽象类，无法实例化。
纯虚函数在类内声明，类外实现。
#include
using namespace std;
#include
class Animal
{
public:
Animal()
{
cout << "Animal 构造函数调用" << endl;
}
virtual void speak() = 0;
//利用虚析构可以解决 父类指针释放子类对象不干净的问题
//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;
}
string *m_Name;
~Cat()//若父类的析构函数没有虚化，则不执行此函数，也就是无法释放堆区数据，导致内存泄露
{
if (m_Name != NULL)
{
cout << "cat的析构函数调用" << endl;
delete m_Name;
m_Name = NULL;
}
}
};
void test01()
{
Animal* animal = new Cat("tom");
animal->speak();
delete animal;
}
int main()
{
test01();
system("pause");
return 0;
}
只有在子类中有堆区数据时，才需要用到虚析构和纯虚析构