【C++】一文简练总结【多态】及其底层原理＆具体应用（21）

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

                                           //多态条件2：被调用的函数 必须是虚函数
class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:                                   //多态条件2：派生类必须对基类的虚函数进行重写
 virtual void BuyTicket() { cout << "买票-半价" << endl; }
/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
这样使用*/
/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};


void Func(Person& p)       //多态条件1：必须通过基类的指针来“引用”调用虚函数
{ 
p.BuyTicket(); 
}


int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
 return 0;
}

class A{};
class B : public A {};
class Person {
public:
 virtual A* f() {return new A;}
};
class Student : public Person {
public:
 virtual B* f() {return new B;}
};

class Person {
public:                  //基类的析构函数为虚函数
 virtual ~Person() {cout << "~Person()" << endl;}
};

class Student : public Person {
public:
  //~Student() { cout << "~Student()" << endl; 不加virtual也行
 virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，
//才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
 Person* p1 = new Person;
 Person* p2 = new Student;
 delete p1;
 delete p2;
 return 0;
}

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

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

class Car
{
public:
virtual void Drive() = 0;         //在虚函数的后面写上 =0,这个函数为 纯虚函数
};

class Benz :public Car
{
public:
 virtual void Drive()
 {
 cout << "Benz-舒适" << endl;  //只有 [ 重写纯虚函数 ] ，派生类才能实例化出对象
 }
};

class BMW :public Car
{
public:
 virtual void Drive()
 {
 cout << "BMW-操控" << endl;
 }
};


void Test()
{
Car* pBenz = new Benz;
 pBenz->Drive();
 Car* pBMW = new BMW;
 pBMW->Drive();
}