C++——多态

多态是有继承关系的类对象调用相同的函数，会有不同的结果。例如，普通人买高铁票不打折，学生打75折，儿童免费，这种情况就适合使用多态

虚函数

被virtual修饰的类成员函数

class A{
public:
    virtual void fun() {}
};

这里的virtual和类的虚继承没有任何关系，只是使用了相同的关键词

多态的条件

1.必须使用基类的指针或引用调用基类的虚函数

2.派生类中必须对被调用的基类中的虚函数进行重写

3.重写的条件：派生类中函数的返回值，函数名和参数列表与基类中的虚函数相同(三同)

（派生类中重写的函数可以不加virtual，因为该成员函数从父类中继承了virtual属性，但是建议加上更规范）

class Person {
public:
	virtual void buy_ticket()
	{
		cout << "full price ticket" << endl;
	}
};
 
class Student :public Person {
public:
	virtual void buy_ticket()
	{
		cout << "half price ticket" << endl;
	}
};
 
void test1()
{
	Person Tom;
	Student Mike;
	
	Person p1 = Mike;
	p1.buy_ticket();
 
	Person* pp = &Mike;
	pp->buy_ticket();
 
	Person& p = Mike;
	p.buy_ticket();
	//full price ticket
	//half price ticket
	//half price ticket
}

final

final修饰虚函数表示这个虚函数不能再被重写

class Person {
public:
	virtual void buy_ticket()
	{
		cout << "full price ticket" << endl;
	}
};
 
class Student :public Person {
public:
	void buy_ticket() final
	{
		cout << "half price ticket" << endl;
	}
};

override

override修饰派生类虚函数,可以检查派生类虚函数是否重写了积累的虚函数，如果没有就会报错

class Person {
public:
	virtual void buy_ticket()
	{
		cout << "full price ticket" << endl;
	}
};
 
class Student :public Person {
public:
	virtual void buy_ticket()override
	{
		cout << "half price ticket" << endl;
	}
};

重写的特例

协变(了解)

重写的的函数返回值不同，且基类的函数返回值是基类对象的指针或引用，派生类的函数返回值是派生类对象的指针或引用。

注意：只要基类和派生类的返回值是继承关系即可，所以函数返回值不一定只是函数所在类的对象的指针或引用

class A {
 
};
 
class B :public A {
 
};
 
class Person {
public:
	virtual const A& fun()
	{
		return A();
	}
};
 
class Student :public Person {
public:
	virtual const B& fun()
	{
		return B();
	}
};

析构函数

析构函数需要重写吗？看下面这个例子

class Person {
public:
	~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	~Student() { cout << "~Student()" << endl; }
};
 
void test2()
{
	Person* p = new Student;
	delete p;
    //~Person()
}

由于没有重写，释放空间p的时候，只调用了Person的析构函数。造成内存泄漏

那么析构函数怎么重写？函数名不一样这怎么办？

编译器对析构函数进行处理，析构函数名都是destructor，我们只要在析构函数前加virtual就可以

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
 
void test3()
{
	Person* p = new Student;
	delete p;
    //~Student()
    //~Person()
}