C++多态、纯虚函数、抽象类、虚析构函数、纯虚析构

多态

• 多态的分类：
  1、静态多态：函数重载和运算符重载属于静态多态，复用函数名。
  2、动态多态：派生类和虚函数实现运行时多态。

• 静态多态和动态区别
  1、静态多态的函数地址早绑定–编译阶段确定函数地址。
  2、动态多态的函数地址晚绑定–运行阶段确定函数地址。

• 多态满足的条件：
  1、有继承关系
  2.、子类重写父类中的虚函数

• 多态使用：
  父类指针或引用指向子类对象。

#include <iostream>
using namespace std;
class Animal{
public:
	virtual void speak() {//speak函数就是虚函数（在函数前加上关键字：virtual）
		cout << "动物在说话" << endl;//
	}
};
class Dog : public Animal {
public:
	void speak() {
		cout << "狗在说话" << endl;
	}
};
class Cat : public Animal {
public:
	void speak() {
		cout << "猫在说话" << endl;
	}
};
//希望传入什么对象就，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，就是静态联编
//如果函数地址在运行阶段就能确定，就是动态联编
void Dospeak(Animal& animal) 
{
	animal.speak();
}
void test()
{
	Cat cat;
	Dospeak(cat);
	Dog dog;
	Dospeak(dog);
}
int main(void)
{
	test();
	return 0;
}

---

多态优点及案例

• 多态优点：
  1、代码组织结构清晰
  2、可读性强
  3、利于前期和后期的扩展以及维护
  计算机类（利用多态技术）

#include <iostream>
using namespace std;
class Abstractcalculator {
public:
	virtual int getresult() {
		return 0;
	}
	int m_a;
	int m_b;
};
class Addcalculator : public Abstractcalculator {//加法
public:
	int getresult() {
		return m_a + m_b;
	}
};
class Subcalculator : public Abstractcalculator {//减法
public:
	int getresult() {
		return m_a - m_b;
	}
};
class Mulcalculator : public Abstractcalculator {//乘法
public:
	int getresult() {
		return m_a * m_b;
	}
};
void test()//使用父类指针的方式
{   //加法计算器
	Abstractcalculator* abc = new Addcalculator;//在堆区开辟
	abc->m_a = 10;
	abc->m_b = 20;
	cout << abc->m_a << " + " << abc->m_b << " = " << abc->getresult() << endl;
	delete abc;//释放
	//减法计算器
    abc = new Subcalculator;
	abc->m_a = 10;
	abc->m_b = 20;
	cout << abc->m_a << " - " << abc->m_b << " = " << abc->getresult() << endl;
	delete abc;
	//乘法计算器
	abc = new Mulcalculator;
	abc->m_a = 10;
	abc->m_b = 20;
	cout << abc->m_a << " * " << abc->m_b << " = " << abc->getresult() << endl;
	delete abc;
}
int main(void)
{
	test();
	return 0;
	}

总结：C++开发提倡利用多态设计程序架构因为多态优点很多。

---

纯虚函数和抽象类

虚函数无意义，因此可以写成纯虚函数。
纯虚函数语法：virtual 返回值类型 函数名 (参数列表) = 0;
当类中有了纯虚函数，这个也称为抽象类。

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

#include <iostream>
using namespace std;
class father {
public:
	virtual void func() = 0;//纯虚函数写法
};
class son : public father {
	virtual void func(){
		cout << "func()的调用" << endl;
	}
};
void test()
{
	father* p = NULL;
//	father p;不允许使用抽象类实例化对象
	son p1;//已在抽象类中重写纯虚函数，所以可实例化
	p = new son;
	p->func();
	delete p;
}
int main(void)
{
	test();
	return 0;
}

---

虚析构和纯虚析构

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

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

• 虚析构与纯虚析构共性：
  1、可以解决父类指针释放子类对象。
  2、都需要有具体的函数实现。

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

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

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

#include <iostream>
#include <string>
using namespace std;
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;//此处想要释放该指针就要在父类中使用虚析构函数或
//纯虚析构函数，否则无法调用到此析构代码
		}
	}
public:
	string *m_name;
};
void test()
{
	Animal *animal = new Cat("Tom");
	animal->speak();
	delete animal;
//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
//解决方法：给基类添加一个虚析构函数
//虚析构函数就是用来解决通过父类指针释放子类对象的问题
}
int main(void)
{
	test();
	return 0;
}

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