C++多态

什么多态（重写）

多态是在不同继承关系的类对象中，去调用同一函数，产生不同的行为。这种行为成为重写

using namespace std;
class Person {
public:
	virtual void BuyTicket() const
	{
		cout << "买票：成人票全价" << endl;
	}
};

class Student : public Person {
public:
	virtual void BuyTicket() const
	{
		cout << "买票：学生票半价" << endl;
	}
};

void func(const Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	func(ps);
	func(st);
	return 0;
}

多态实现的条件

1）首先多态的实现是建立在继承关系的基础上。
2）被调用的函数必须是虚函数并且完成了虚函数的重写。
3）调用函数的对象的类型必须是父类指针或者引用。

虚函数

1. 调用函数是重写的虚函数：虚函数重写的条件为，返回类型相同，函数名字相同，参数列表形同。但是还有一些例外也是可以实现虚函数的，例如派生类重写的虚函数钱可以不加virtual，和协变都是例外**
2. 基类是指针或引用

协变

协变的返回值可以不同，但是要求返回值必须是父子类关系（先父后子）指针或引用，不能结合使用

using namespace std;
class Person {
public:
	virtual Person* BuyTicket() const
	{
		cout << "买票：成人票全价" << endl;
		return 0;
	}
};

class Student : public Person {
public:
	virtual Student* BuyTicket() const
	{
		cout << "买票：学生票半价" << endl;
		return 0;
	}
};

//
void func(const Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	func(ps);
	func(st);
	return 0;
}

析构函数

析构函数是可以为虚函数的，因为如果析构函数不是虚函数那么有些情况下就会发生内存泄漏。
析构函数前加virtual也是构成了虚函数的重写，且类析构函数都被处理成destructor这个统一的名字

class Person {
public:
	virtual void BuyTicket() const
	{
		cout << "买票：成人票全价" << endl;
	}
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Student : public Person {
public:
	virtual void BuyTicket() const
	{
		cout << "买票：学生票半价" << endl;
	}

	virtual ~Student()
	{
		cout << "~Student()" << endl;
	}
};

//
void func(const Person& p)
{
	p.BuyTicket();
}

int main()
{
	//Person p;
	//Student s;

	Person* p = new Person;
	p->BuyTicket();
	delete p;

	p = new Student;
	p->BuyTicket();
	delete p; // p->destructor() + operator delete(p)

	// 这里我们期望p->destructor()是一个多态调用，而不是普通调用

	return 0;
}

如果析构函数前面不加virtual，那么就会发生内存泄漏

怎样做可以不让重写

C++11提供了override和final两个关键字，可以帮助我们检测是否重写。
final 直接不让重写
override 帮助派生检查是否完成重写，如果没有会报错

重载、覆盖(重写)、隐藏(重定义)的对比