【c++】多态

概念

多态（Polymorphism）是面向对象编程（OOP）中的一个重要概念，指的是同一个接口或方法在不同情况下表现出不同的行为。多态性允许不同的类对同一消息做出不同的响应，增强了代码的灵活性和可扩展性。多态分为运行时多态（动态多态）和，编译时多态（静态多态），在这里我们主要介绍运行时多态。

编译时多态（静态多态）

编译时多态就是我们前边讲的函数重载和函数模板，传不同的参数就会调用不同的函数，通过参数不同来达到多种形态。函数重载和函数模板在编译时就已经确定要调用的函数，所以称为编译时多态（静态多态），实参传给形参的参数匹配是在编译时完成的。

运行时多态（动态多态）

不同于编译时多态，运行时多态在编译时还没有确认要调用函数，在要调用一个函数时，不同的对象去调用，完成的行为是不一样的。例如，同样一个叫声的函数，用Dog(狗)类型实例化出的对象调出来的是 '汪汪'。用Cat(猫)类实例化出的对象去调出来的则是’喵喵‘。

运行时多态通过不同类型的对象去调用实现多种形态，编译时多态通过参数匹配来实现多种形态。

多态的定义和实现

多态是继承关系下的类对象，去调用同一函数，产生不同的行为。

实现多态的两个必须条件

• 必须是基类的指针或者引⽤调⽤虚函数

• 被调⽤的函数必须是虚函数，并且完成了虚函数重写/覆盖。

class Person
{
public:virtual void buyticket(){cout << "全价买票" << endl;}
private:
};class Student :public Person
{
public:virtual void buyticket(){cout << "七五折买票" << endl;}
};
void func(Person& a)
{a.buyticket();
}
int main()
{Person a;Student b;func(a);func(b);return 0;
}

如果func()中参数类型为Student:

class Person
{
public:virtual void buyticket(){cout << "全价买票" << endl;}
private:
};class Student :public Person
{
public:virtual void buyticket(){cout << "七五折买票" << endl;}
};
void func(Student& a)
{a.buyticket();
}
int main()
{Person a;Student b;func(a);func(b);return 0;
}

如果buyticket()不是虚函数：

class Person
{
public:void buyticket(){cout << "全价买票" << endl;}
private:
};class Student :public Person
{
public:virtual void buyticket(){cout << "七五折买票" << endl;}
};
void func(Person& a)
{a.buyticket();
}
int main()
{Person a;Student b;func(a);func(b);return 0;
}

 虚函数

类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。注意⾮成员函数不能加virtual修

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

class Person
{
public:virtual void buyticket(){cout << "全价买票" << endl;}
};class Student:public Person
{
public:void buyticket()//不加virtual也是虚函数{cout << "半价买票" << endl;}
};void func(Person* ptr)
{ptr->buyticket();
}int main()
{Person a;Student b;a.buyticket();b.buyticket();return 0;
}

观察下面一段代码：

class A
{
public:virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }virtual void test() { func(); }
};
class B : public A
{
public:void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{B* p = new B;p->test();return 0;
}

 这段程序的输出结果是什么呢？

p是指向B类型的指针，指向谁，谁调用，所以是调用B类型中的func()函数，但是这里要注意一点：默认参数的值是根据调用者的静态类型（编译时）决定的，而不是动态类型（运行时）。也就是说，编译器在编译时会根据调用者的静态类型来确定默认参数的值。val在编译时就已经确定为1，所以不会再运行时调用B的func()而改变。

所以这道题的答案时B->1。

析构函数的重写

如果基类的析构函数为虚函数，那么在派生类中，只要定义了虚函数，⽆论是否加virtual关键字，都与基类的析构函数构成重写。这样似乎和重写的定义有些不符，这是一个特殊情况，编译后析构函数的名称统⼀处理成destructor。那么，为什么要这样处理呢？如果没有虚函数重写，当我们通过基类指针或引用管理派生类成员时，析构时仅会调用基类的析构函数，会导致内存的泄露。

class Base {
public:~Base() { std::cout << "Base destructor" << std::endl; }
};class Derived : public Base {
public:~Derived() { std::cout << "Derived destructor" << std::endl; }
};int main() {Base* ptr = new Derived();delete ptr;  // 仅调用 Base 的析构函数，Derived 的析构函数不会被调用！return 0;
}

override和final关键字

class Car {
public:void Drive()//不给基类的Drive()加virtual{}
};
class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{return 0;
}

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

重载/重写/隐藏对比

 纯虚数和抽象类

class Car
{
public:virtual void Drive() = 0;
};
class Benz :public Car
{
public:virtual void Drive(){cout << "Benz-舒适" << endl;}
};class BMW :public Car
{
public:virtual void Drive(){cout << "BMW-操控" << endl;}
};
int main()
{// 编译报错：error C2259: “Car”: 无法实例化抽象类Car car;Car* pBenz = new Benz;pBenz->Drive();Car* pBMW = new BMW;pBMW->Drive();return 0;
}

多态的原理

观察下面一段程序，在64位系统下，判断程序的输出结果。

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
protected:int _b = 1;char _ch = 'x';
};
int main()
{Base b;cout << sizeof(b) << endl;return 0;
}

程序的结果为16

在不加virtual的情况下结果8。 这是为什么呢？

当一个类中，如果有virtual标记的函数，那么在编译时，会生成一个虚函数表，具体位置在全局数据区的只读数字段当中，会将虚函数的地址存到虚函数表中。虚函数表指针(v代表virtual，f代

在64位系统中，指针为8字节，所以上面程序的结果为16。

多态时如何实现的

class Person {
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:string _name;
};
class Student : public Person {
public:virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:string _id;
};
class Soldier : public Person {
public:virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:string _codename;
};
void Func(Person* ptr)
{// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。ptr->BuyTicket();
}
int main()
{// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后// 多态也会发⽣在多个派⽣类之间。Person ps;Student st;Soldier sr;Func(&ps);Func(&st);Func(&sr);return 0;
}

几个类对象在Func()函数中都是通过ptr调用BuyTicket()函数，那么是怎么做到ptr指向不同的对象就在不同的类中调用函数的呢？编译时，生成虚函数表，在运行时会绑定具体的虚函数地址（不同的类虚函数表是不同的），然后就可以根据指向对象的不同调用不同类的虚函数。

下面是调试时上面程序三个对象的虚函数表指向的内容：

ps虚表中指向的是Person::BuyTicket

st的虚表中指向的是Student::BuyTicket

sr的虚表中指向的是Soldier::BuyTicket

动态绑定和静态绑定 

class Base {
public:void show() { cout << "Base show" << endl; }  // 非虚函数
};class Derived : public Base {
public:void show() { cout << "Derived show" << endl; }  // 隐藏基类函数
};int main() {Derived d;Base* pb = &d;pb->show();  // 静态绑定，调用Base::show()return 0;
}

class Base {
public:virtual void show() { cout << "Base show" << endl; }  // 虚函数
};class Derived : public Base {
public:void show() override { cout << "Derived show" << endl; }  // 重写虚函数
};int main() {Derived d;Base* pb = &d;pb->show();  // 动态绑定，调用Derived::show()return 0;
}