C++的多态

多态——函数调用的多种形态
静态的多态——函数重载
静态：指编译时

//静态的多态
int main()
{
	int i;
	char ch;
	cin >> i;
	cin >> ch;

	cout << i << endl;  //调用的是operatoe>>(int i)
	cout << ch << endl;//调用的是operaatoe>>(char ch)
	return 0;
}

动态的多态——父类指针或引用调用重写函数
动态：指运行时
1.父类指针或者引用指向父亲，调用的就是父类的虚函数
2.父类指针或者指向哪个子类，调用的就是子类的虚函数

不同的类型对象，去完成同一件事情，产生的动作是不一样的，结果也不一样

继承中构成多态的两个条件（缺一不可）：
1.必须通过基类的指针或者引用调用虚函数（虚函数：在类成员函数前面加上virtual）
2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
虚函数的重写：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称子类的虚函数重写了基类的虚函数

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}

};
class Student : public Person
{
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
class Soldier : public Person
{
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-优先" << endl;
	}
};
void f(Person& p)
{
	//传不同类型的对象，调用的不同的函数
	//实现了调用的多态形态
	p.BuyTicket();
}

void f(Person* p)
{
	//传不同类型的对象，调用的不同的函数
	//实现了调用的多态形态
	p->BuyTicket();
}
int main()
{
	Person p;  //普通人
	Student st; //学生
	Soldier so; //军人
	
	//引用输出
	f(p);
	f(st);
	f(so);

	cout << endl;
	//指针输出
	f(&p);
	f(&st);
	f(&so);
	return 0;
}

注意：
1.只有类的非静态成员函数可以是虚函数
2.虚函数这里的virtual和虚继承中用的virtual是同一个关键字，但是它们之间没有关系
虚函数是为了实现多态
虚继承是为了解决菱形继承的数据冗余和二义性

虚函数重写的例外：
1.协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
A与B是父子关系，若A与B不是父子关系则不构成虚函数重写

//虚函数重写例外
class A{};
class B : public A {};
class Person {
public:
	virtual A* f() 
	{ 
		cout << "Person::A* f()" << endl;
		return new A; 
	}
};
class Student : public Person {
public:
	virtual B* f()
	{
		cout << "Student::B* f()" << endl;
		return new B;
	}
};

int main()
{
	Person p;
	Student s;

	Person* ptr;
	ptr = &p;
	ptr->f();

	ptr = &s;
	ptr->f();
}

2.析构函数的重写(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

子类的析构函数与父类的析构函数构成隐藏，明面上名字不一样，但为了重写，编译器会对析构函数名字调用时，统一改成destructor()

//析构函数的重写
class Person
{
public:
	//建议把父类析构函数定义为虚函数
	//方便子类的虚函数重写
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}

};
class Student :public Person
{
public:
	//Student与Person析构函数的函数名看起来不同，但构成虚函数的重写

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

};

int main()
{
	//在普通场景下，父子类的析构函数是否构成重写，不重要

	Person p;
	Student s;

	Person* p1 = new Person;
	Person* p2 = new Student;

	//期望实现多态，p1调用父类析构函数，p2调用子类析构函数
	//若不是子类析构函数没有重写父类，本应该调用子类析构函数，但是没有调用，可能存在内存泄露
	//若子类析构函数有清理则会泄露
	delete p1;//p1->析构函数（） + operator delete(p1)  改为p1->destructor(); + operator delete()
	delete p2;//p2->析构函数（） + operator delate(p2)
	return 0;
}

3.子类的虚函数省去virtual，也构成析构函数的重写，父类不能省略，因为子类是继承父类，已有virtual

虚函数不想被重写，加关键字final

class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() {cout << "Benz-舒适" << endl;}
};

override检查是否完成了重写，没有完成重写则会报错

class Car{
public:
	virtual void Drive(){}
};
class Benz :public Car {
public:
	virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

重载、重写、重定义