C++多态（全）

多态

概念

调用函数的多种形态，

多态构成条件

1）父子类完成虚函数的重写（三同：函数名，参数，返回值相同）

2）父类的指针或者引用调用虚函数

虚函数

被virtual修饰的类成员函数

注意

1）只有类的非静态成员函数前才可以加上virtual

2）虚函数的virtual与虚继承的virtual是同一个关键字。虚函数中的virtual是为了实现多态，虚继承的virtual是为了菱形继承中数据冗余和二义性。

虚函数的重写

也叫虚函数的覆盖

派生类中有一个完全相同的虚函数（返回值类型相同，函数名相同，参数列表相同），就叫做派生类的虚函数重写了基类的虚函数

结果：通过父类Person的指针或引用调用虚函数

父类指针要是指向父类对象则调用父类的虚函数

要是指向子类对象则调用子类虚函数

#include<iostream>
using namespace std;
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票半价" << endl;
	}
};
class Student :public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票半价" << endl;
	}
};
void Func(Person& people)
{
	people.BuyTicket();
}
int main()
{
	Student s;

	Func(s);
	return 0;
}

注意

1）派生类的虚函数可以不用加上virtual关键字（不规范，建议加上）

虚函数的两个例外

1）协变

基类和派生类的返回值不同

当基类虚函数返回基类对象的指针或引用

派生类虚函数返回派生类对象的指针或引用

#include<iostream>
using namespace std;

//基类
class A
{};
//子类
class B : public A
{};
//基类
class Person
{
public:
	//返回基类A的指针
	virtual A* fun()
	{
		cout << "A* Person::f()" << endl;
		return new A;
	}
};
//子类
class Student : public Person
{
public:
	//返回子类B的指针
	virtual B* fun()
	{
		cout << "B* Student::f()" << endl;
		return new B;
	}
};
void Func(Person& p)
{
	p.fun();
}
int main()
{
	Student s;

	Func(s);
	return 0;
}

2）析构函数的重写

基类和派生类的析构函数名字不同

当基类的析构函数是虚函数，只要派生类析构函数定义，就构成重写

作用：

要是没有重写，指向子类的指针只会调用父类的析构函数，有可能造成内存泄漏

注意：

在继承中，子类和父类的析构函数会构成隐藏就是因为，虽然子类析构函数和父类的析构函数函数名虽然不同，但是为了构成重写，编译后的析构函数名字会统一处理为destructor（）；

void test2()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	//本来希望指向父类的指针析构父类
	//指向子类的指针去析构子类
	//因此需要虚函数，构成重写
}

c++11

1）override：检查派生类虚函数是否重写了基类的某个虚函数，没有则编译错误

//子类
class Student : public Person
{
public:
	//子类完成了父类虚函数的重写，编译通过
	virtual void BuyTicket() override
	{
		cout << "买票-半价" << endl;
	}
};

2）final：修饰虚函数，表示该虚函数不能再重写

//父类
class Person
{
public:
	//被final修饰，该虚函数不能再被重写
	virtual void BuyTicket() final
	{
		cout << "买票-全价" << endl;
	}
};

易错例题

纯虚函数

在虚函数后面写上=0

抽象类（接口类）：包含纯虚函数的类

特点

1）抽象类不能实例化对象

2）强制派生类重写虚函数（不重写则会继承纯虚函数，又变为抽象类了又不能实例化对象了）

3）用抽象类（父类）的指针调用虚函数

作用

1）抽象类能更好的

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
int main()
{
	Car c; //抽象类不能实例化出对象，error
	return 0;
}

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
//派生类
class Benz : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
//派生类
class BMV : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "BMV-操控" << endl;
	}
};
int main()
{
	//派生类重写了纯虚函数，可以实例化出对象
	Benz b1;
	BMV b2;
	//不同对象用基类指针调用Drive函数，完成不同的行为
	Car* p1 = &b1;
	Car* p2 = &b2;
	p1->Drive();  //Benz-舒适
	p2->Drive();  //BMV-操控
	return 0;
}