多态——函数调用的多种形态
静态的多态——函数重载
静态：指编译时
//静态的多态
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;}
};
重载、重写、重定义
