什么是多态性，C++中是如何实现多态的

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了什么是多态性，C++中是如何实现多态的相关的知识，希望对你有一定的参考价值。

多态按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。

多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。

举个例子：例如ATM机。世界上有非常多的银行，每个银行都有好多种卡。如果ATM需要为每一种卡写一种方法去调用，例如getMoney(CCBCard card)，getMoney(BBCard card)就会非常的麻烦。而且维护起来就是灾难性的。因为每时每刻都可能会有新的卡出现。所以我们可以采用多态
getMoney(Card card)，所有的银行卡都继承Card这个类。这样就可以避免为每一种卡写一个方法。但是每一种卡的使用方法，作用都不一样，Card如何调用每一种卡不同的内容呢？
这就需要多态。让你看起来像是操作的父类，但是实际的运行内容却是子类的内容。
下面有一段代码，你可以参考一下。

用父类的指针或者引用指向子类对象，来实现多态的作用

class A
public:
　　A()
　　virtual void foo()
　　cout << "This is A." << endl;

;
class B : public A
public:
　　B()
　　void foo()
　　cout << "This is B." << endl;
　　
;
int main(int argc, char* argv[])
　　A *a = new B();
　　a->foo();
　　if(a != NULL)
　　delete a;
　　return 0;

这将显示：
This is B.
如果把virtual去掉，将显示：
This is A.
前面的多态实现使用抽象类,并定义了虚方法. 参考技术A 　　C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板（重载和多态无关）。
　　虚函数是指在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数，用法格式为：virtual 函数返回类型 函数名（参数表） 函数体；实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。
　　C++为了让一个类成为抽象类，至少必须有一个纯虚函数。包含至少一个纯虚函数的类视为抽象类。 参考技术B 我举个通俗一点的例子吧，

比如生物是一个类，生物类里面包含了一个类叫鸟类
生物*是爸爸（父类），鸟类**是儿子（子类），鱼类**是二儿子（子类）。龙生九子，各不相同。
生物*的特点活的，有细胞，儿子 鸟类**继承了爸爸活的，有细胞，还延伸出了一个特点有翅膀，所以鸟类**的特点是活的，有细胞，有翅膀；
而鱼类**也延伸出自己的特点，有鳃，所以鱼类的特点活的，有细胞，鳃。
——————————————————
问题：这tm不是继承性吗？关多态性屁事？
划重点：没有继承性，就不会有多态性的存在（面向对象三大特性：封装、继承、多态）。
多态性（基于继承所显示的多重特性）。所以！
只要发现了“翅膀”，人们可以立刻判断是鸟，第二反应是它还是生物呢~~~
发现“鳃”，哦，它是鱼类，第二反应，它也是生物呀~~~
————————————————————————
多态性可以快速的判断事物本身的特点，而不用通过依赖顺序判断（先判断是不是生物，再查找有没有翅膀），明明就有个“鳃”你看见了，这就是一条鱼！何必多此一举？？？？
————————————————————————————
补充关于非多态的继承：
举个栗子：
父类是车承重1-100，速度1-100，跑车是车的子类，
跑车承重1-10，速度90-100，
卡车承重90-100，速度10-20，
OK？没有显示出特点，只是划分了更精确的区间。
所以！划重点：
——————————————————————————
多态，继承等等是概念！概念！概念！理解这个概念，而不是片面断裂的人为划界限！
因为面向对象这三个特性是融合在一体的，缺一不可，缺了，就“没对象了”，哈哈哈哈~~

C++ 多态相关

什么是多态？虚函数的实现原理是什么?

多态分为静态多态和动态多态

  • 静态多态：发生在编译时，主要有函数重载，运算符重载
  • 动态多态：发生在运行时，主要通过虚函数的形式实现
    多态性可以概括为"一个接口，多种方法"，程序在运行时才决定调用的函数，多态性是oop编程的核心，C++的多态性通过虚函数实现，基类中定义虚函数，允许子类继承并且可以重新定义该函数的实现，这也就是覆盖。多态的目的就是为了接口的重用。也就是说，无论传递过来的是哪个类的对象，函数都可以通过接口调用到适合各自对象的实现方法。
    最常见的用法就是声明一个基类指针或者引用，然后该指针或者引用绑定一个派生类的对象，调用相应对的虚函数，可以根据指向的派生类的不同而实现不同的方法。

虚函数实现原理：当在类中定义一个虚函数，则该类所实例化的对象的存储位置将会多一个vfptr指针，该指针指向一个虚函数表，虚函数表中存放的就是虚函数的入口地址

构造函数能设置为虚函数吗？为什么？

构造函数不能设置为虚函数，虚函数就是为实现C++的OOP编程中的多态性而设定的，而动态多态性的激活条件是：

  • 基类中有定义虚函数，同时其派生类中有定义该函数的覆盖函数；
  • 创建派生类对象
  • 定义一个基类的指针或者引用，同时绑定到其派生类的对象中； 通过已经定义的基类指针或者引用调用相应的虚函数

==由上面动态多态性的激活条件可以知道，要使用虚合理函数，则必须先创建派生类的对象，而在创建派生类对象的过程中必将调用其基类的构造函数，而如果基类中的构造函数是虚函数，而此时派生类对象又没有创建，陷入了矛盾的境地，所以构造函数不能设置为虚函数，同时也是没有任何意义的一件事==

在什么情况下析构函数要设置成虚函数？为什么？

当基类中的数据成员申请了堆空间，同时该基类中也定义了析构函数用于销毁该空间和虚函数。如果该基类有一个派生类，该派生类中也申请了一块堆空间。这时我们如果new一个派生类中空间，把new表达式返回的派生类指针赋给一个基类指针。如果我们使用delete表达式来释放刚才申请的派生类空间，这时只会调用基类的析构函数，不会调用派生类的析构函数，因为已经把派生类的指针赋给了基类指针。这时我们应该把析构函数设置为虚函数，在调用派生类的析构函数的同时，也将会调用基类的析构函数，这时所有申请的资源都得到了释放。代码如下：

#include <string.h>

#include <iostream>

using std::cout;
using std::endl;

class Base

public:
    Base(const char * base)
    : _base(new char[strlen(base) + 1]())
    
        strcpy(_base, base);
        cout << "Base(const char * base)" << endl;
    

    virtual void print(void) const
    
        cout << "base = " << _base << endl;
    

    ~Base()
    
        if (_base)
            delete [] _base;
        cout << "~Base()" << endl;
    

private:
    char * _base;
;

class Derived
: public Base

public:
    Derived(const char * base, const char * derived)
    : Base(base)
    , _derived(new char[strlen(base) + 1]())
    
        strcpy(_derived, derived);
        cout << "Derived(const char * base, const char * derived)" << endl;
    
    
    void print(void) const 
    
        cout << "derived = " << _derived << endl;
    

    ~Derived()
    
        if (_derived)
            delete [] _derived;
        cout << "~Derived()" << endl;
    
private:
    char * _derived;

;

int main(void)

    Base * base = new Derived("hello", "world");
    base->print();

    delete base;

    return 0;

运行结果

Base(const char * base)
Derived(const char * base, const char * derived)
derived = world
~Base()

分析：对于虚函数的调用这里就不再分析，就是派生类将基类的虚函数给覆盖了，这时从基类对象调用基类中的虚函数，将会调用派生类的虚函数。这里分析析构函数，通过运行结果可知，在delete base时，基类的析构函数被调用了，但是派生类的析构函数没有被调用，也就是说，基类中申请的堆资源得到了释放，而派生类中的资源没有得到释放，这不是我们想要的结果，原因上面已经分析了。要解决这个问题，应该想到，在调用派生了析构函数时，基类的析构函数也会被自动调用，我们可以尝试调用派生类的析构函数，那么怎么调用派生类的析构函数呢？这里可以利用虚函数的覆盖特性，我们把基类的析构函数设置为virtual，这时delete base时将调用派生类的析构函数，达到了我们的目的，代码修改如下：

virtual
    ~Base()
    
        if (_base)
            delete [] _base;
        cout << "~Base()" << endl;

运行结果：

Base(const char * base)
Derived(const char * base, const char * derived)
derived = world
~Derived()
~Base()

当基类析构函数设置为虚函数后，其派生类析构函数会自动成为虚析构函数，即使没有加上virtual关键字，如果接下来要调用析构函数，就会走虚函数的调用机制

在基类的普通成员函数内部调用虚函数时的情况

#include <iostream>

using std::cout;
using std::endl;

class Base 

public:
    Base() = default;

    Base(int base_val)
    : _base_val(base_val)
    
        cout << "Base(int base_val)" << endl;
    

    void func1(void)
    
        //this->display();
        display();
    

    void func2(void)
    
        Base::display();
    

    virtual void display(void) const
    
        cout << "base_val = " << _base_val << endl;
    

private:
    int _base_val;

;

class Derived
: public Base

public:
    Derived(int base_val, int derived_val)
    : Base(base_val)
    , _derived_val(derived_val)
    
        cout << "Derived(int base_val, int derived_val)" << endl;
    

    void display(void) const
    
        cout << "derived_val = " << _derived_val << endl;
    
private:
    int _derived_val;
;

int main(void)

    Base base(12);
    base.func1();

    Derived derived(34, 56);
    derived.func1();

    cout << "-----------" << endl;
    base.func2();
    derived.func2();

    return 0;

运行结果：

Base(int base_val)
base_val = 12
Base(int base_val)
Derived(int base_val, int derived_val)
derived_val = 56
-----------
base_val = 12 base_val = 34

分析：由上面的代码可知，display()函数定义为了虚函数，同时在基类中的func1 和 func2 函数中通过两种方式来访问该虚函数； Base base(12); base.func1();对于这段代码很好理解，就是基本的创建对象，然后访问对象中的成员，只不过在该成员中访问了该对象的虚函数，但由于没有继承关系，所以和普通的访问没有区别；

Derived derived(34, 56);
derived.func1();

对于这段代码，由于 Derived类继承自Base类，在继承了基类中的 func1、func2和虚函数后，由于Derived类中重新定义了该虚函数，这时子类的同名函数会覆盖基类中的虚函数，所以这时func1调用的就是子类中重定义的虚函数；

base.func2();
derived.func2();

上面的代码通过运行结果可知，虽然是derived对象调用的func2函数，但是该函数内部通过作用域运算符调用了虚函数，这时的调用将会直接调用基类中的虚函数，而不会调用派生类中的虚函数

在基类的构造函数和析构函数内部调用虚函数时的情况

#include <iostream>

using std::cout;
using std::endl;

class Grandpa 

public:
    Grandpa(int grandpa_val)
    : _grandpa_val(grandpa_val)
    
        cout << "Grandpa(int grandpa_val)" << endl;
    

    virtual
    void func1(void)
    
        cout << "Grandpa: func1()" << endl;
    

    virtual
    void func2(void)
    
        cout << "Grandpa: func2()" << endl;
    

    ~Grandpa()
    
        cout << "~Grandpa()" << endl;
    
private:
    int _grandpa_val;

;

class Son
: public Grandpa

public:
    Son(int grandpa_val, int son_val)
    : Grandpa(grandpa_val)
    , _son_val(son_val)
    
        cout << "Son(int grandpa_val, int son_val)" << endl;
        func1();
    

#if 1
    void func1(void)
    
        cout << "Son: func1()" << endl;
    

    void func2(void)
    
        cout << "Son: func2()" << endl;
    

#endif 

    ~Son()
    
        cout << "~Son()" << endl;
        func2();
    
private:
    int _son_val;
;

class Grandson
: public Son

public:
    Grandson(int grandpa_val, int son_val, int grandson_val)
    : Son(grandpa_val, son_val)
    , _grandson_val(grandpa_val)
    
        cout << "Grandson(int grandpa_val, int son_val, int grandson_val)" << endl;
    

    void func1(void)
    
        cout << "Grandson: func1()" << endl;
    

    void func2(void)
    
        cout << "Grandson: func2()" << endl;
    

    ~Grandson()
    
        cout << "~Grandson()" << endl;
    

private:
    int _grandson_val;
;

int main(void)

    Grandson test(1, 2, 3);
    //cout << "-------------/\n";
    Grandpa  & tt = test;
    cout << "-------------/\n";
    tt.func1();
    return 0;

运行结果

Grandpa(int grandpa_val)
Son(int grandpa_val, int son_val)
Son: func1()
Grandson(int grandpa_val, int son_val, int grandson_val)
-------------/
Grandson: func1()
~Grandson()
~Son()
Son: func2()
~Grandpa()

由代码和运行结果可知，当我们在构造函数或者析构函数内部调用虚函数，虽然表面上看和动态联编没说区别，但是，在这两个函数体内调用虚函数，其实本质上调用的是自身类中的函数(不是虚函数)，或者说没有从虚函数的机制进行调用，而是按照普通函数的机制进行调用(静态联编)

验证虚函数表的存在

我们知道，如果一个基类中定义了虚函数，同时派生类中覆盖了该虚函数，这时实例化派生类时创建的派生类对象的存储空间当中将会多一个指向虚函数表的指针，使得能够表现为动态多态的性质，这里就对虚函数表的存在进行验证，代码如下：

#include <iostream>

using std::cout;
using std::endl;

class Base

public:
    Base(long base_val)
    : _base_val(base_val)
    
        cout << "Base(int base_val)" << endl;
    

    virtual 
    void func1(void)       cout << "Base::func1()" << endl;    

    virtual 
    void func2(void)       cout << "Base::func2()" << endl;    

    virtual 
    void func3(void)       cout << "Base::func3()" << endl;    

private:
    long _base_val;

;

class Derived
: public Base

public:
    Derived(long base_val, long derived_val)
    : Base(base_val)
    , _derived_val(derived_val)
    
        cout << "Derived(long base_val, long derived_val)" << endl;
    

    virtual 
    void func1(void)       cout << "Derived::func1()" << endl;    

    virtual 
    void func2(void)       cout << "Derived::func2()" << endl;    

    virtual 
    void func3(void)       cout << "Derived::func3()" << endl;    

private:
    long _derived_val;
    
;

int main(void)

    Base base(10);
    cout << "sizeof(Base) = " << sizeof(Base) << endl;  

    long * p = (long *)&base;
    cout << p[0] << endl;
    cout << p[1] << endl; 

    typedef void (*Function)(void);

    long * p2 = (long *)p[0];
    Function f = (Function)p2[0];
    //Function f = (Function)p[0][0];
    f();

    f = (Function)p2[1];
    f();

    f = (Function)p2[2];
    f();

    return 0;

运行结果

Base(int base_val)
sizeof(Base) = 16
94272637283664
10
Base::func1()
Base::func2()
Base::func3()

编译和运行环境是gcc version 7.4.0 (Ubuntu 7.4.0-1ubuntu1~18.04.1) ，所以系统的是64位的，所以在指针的大小是8个字节(64位)，所以为了方便验证，这里用long类型的来存储数据。我们知道，对象base的在栈中的大小是16个字节，其中8个字节的long类型数据，8个字节的指针，指针也就是vfptr指针，指向虚函数表的，这里就是验证虚函数表是否真的存在。对对象base取地址，强制转换为long类型，看 p[1]数据，就是我们一开始初始化base对象时赋的值， p[0] 则是一个指针，指向虚函数表，因为指针的大小是8个字节，所以我们再一次把 p[0]强制转换为long* 类型，从程序中我们可以看出来，p[0] 中共有3个指针，也就是 p2中的数据，因为 p2中的数据是8个字节的指针，但编译器无法识别这个地址数据，所以我们把该数据强制转换为指针函数，这样就可以调用虚函数了。从而验证了虚函数表哦的存在性

什么是纯虚函数？什么是抽象类？抽象类的作用是什么？

  • 纯虚函数指的在基类中的是一个虚函数没有定义，而是在声明该纯虚函数的时候在后面添加 = 0;即可，这时基类中的虚函数就是纯虚函数
  • 如果在基类中定义纯虚函数，则该基类就是抽象基类，抽象基类只向外提供接口，而不能实例化对象，当该基类的派生类可以实例化对象，不过前提是这些派生类定义了覆盖这些纯虚函数的函数，通过这里我们就一目了然了，抽象基类只负责提供接口的定义，不负责接口的实现，接口的实现由该基类的派生类来完成。代码如下：
#include <math.h>

#include <iostream>

using std::cout;
using std::endl;

class Figure            //定义一个抽象基类

public: 
    virtual void display(void) const = 0;   //定义纯虚函数
    virtual double area(void) const = 0;
;

void display(Figure & figure)

    figure.display(); 
    cout << ", the area is " << figure.area() << endl;


class Circle
: public Figure

public:
    Circle(double radius)
    : _radius(radius)
    

    void display(void) const
    
        cout << "I am Circle";
    

    double area(void) const
    
        return 3.14 * _radius * _radius;
    

private:
    double _radius;
;

class Rectangle
: public Figure

public:
    Rectangle(double length, double width)
    : _length(length)
    , _width(width)
    

    void display(void) const
    
        cout << "I am Rectangle";
    

    double area(void) const
    
        return _length * _width;
    

private:
    double _length;
    double _width;
;

class Triangle
: public Figure

public:
    Triangle(double a, double b, double c)
    : _a(a)
    , _b(b)
    , _c(c)
    

    void display(void) const
    
        cout << "I am Triangle";
    

    double area(void) const
    
        double p = (_a + _b + _c)/2;
        return sqrt(p * (p - _a) * (p - _b) * (p - _c));
    

private:
    double _a;
    double _b;
    double _c;
;

int main(void)

    Circle circle(10);
    Rectangle rec(10, 12);
    Triangle triangle(3, 4, 5);

    display(circle);
    display(rec);
    display(triangle);


    return 0;

运行结果：

I am Circle, the area is 314
I am Rectangle, the area is 120
I am Triangle, the area is 6

分析：从上面的代码可以知道，Figure为抽象基类，只定义向外提供的各种接口，而实现则由该基类的派生类来完成，在main函数中也可以看出来，调用同一个函数，但结果却是不一样的。这种抽象基类遵循的原则是：对修改关闭(不需要修改原来的代码)，对扩展开放。
另：对于这种抽象基类应该注意的是，只要基类中有定义的纯虚函数，则其派生类中必须对基类中的所有纯虚函数给予实现，只要有一个纯虚函数没有实现，则该派生类也不能创建对象。
上面是按照定义纯虚函数来实现抽象类，这里还有另外一种抽象类，就是将基类的构造函数设置为protected，这时的基类是不能实例化对象的，要调用基类的构造函数，通过该基类派生出子类，实例化该子类，通过该对象来调用基类中可以访问的成员，代码如下：

#include <iostream>

using std::cout;
using std::endl;

class Base

public:
    virtual void print(void)
    
        cout << "I am Base_class" << endl;
        cout << "base_val = " << _base_val << endl;
    

protected:              //把基类的构造函数定义为protected性质，这时外部非派生类将不能对该类进行实例化，只能通过该类的派生来调用该基类的构造函数
    Base(int base_val)
    : _base_val(base_val)
    
        
        cout << "Base(int base_val)" << endl;
    

private:
    int _base_val;
;

class Inherit_cls
: public Base

public:
    Inherit_cls(int base, int inherit_val)      //通过派生类中的构造函数来调用基类中的构造函数
    : Base(base)
    , _inherit_val(inherit_val)
    
        cout << "Inherit_cls(int base, int inherit_val) " << endl;
    

    void print(void)
    
        cout << "I am Inherit_cls" << endl;
        cout << "inherit_val = " << _inherit_val << endl;
    

private:
    int _inherit_val;

;

int main(void)

    Inherit_cls test(12, 34);
    Base & base = test;
    base.print();

    return 0;

分析：上面的代码中是C++语言的动态多态性，但是把基类中的构造函数设置为了protected，这时是无法通过该基类来创建基类对象，只能通过基类的派生类创建对象，这种抽象类的功能相比较前一种而言弱了很多，对于抽象类，应该使用纯虚函数来实现。

什么是重载？什么是隐藏？什么是覆盖？他们之前的区别是？

  • 重载：重载可以在同一个类中，也可以是普通函数，只要函数的名称相同但是函数的参数个数，参数类型，返回值不同，就可以实现重载
  • 隐藏：隐藏指的有继承关系的父子类中的同名函数，如果基类中有一个函数function，而子类中也有一个函数function，这时将会隐藏基类中的function函数，想要调用基类中的function函数，只需要加一个作用域限定符即可
  • 覆盖：指的是虚函数，如果基类中定义了一个虚函数，同时该基类的派生类也定义了与基类中同名、同返回值、同参数列表的函数(可以没有virtual修饰)，这时实例化该派生类对象，这时派生类中的虚函数将会覆盖掉从基类中继承过来的虚函数

多重继承虚函数的情况

#include <iostream>

using std::cout;
using std::endl;

class A

public: 
    virtual
    void f(void)       cout << "A::f()" << endl;   

    virtual 
    void g(void)       cout << "A::g()" << endl;   

    virtual 
    void h(void)       cout << "A::h()" << endl;   
;

class B

public: 
    virtual
    void f(void)       cout << "B::f()" << endl;   

    virtual 
    void g(void)       cout << "B::g()" << endl;   
 
    void h(void)       cout << "B::h()" << endl;   

    void j(void)       cout << "B::j()" << endl;   
;

class C 
: public A
, public B

public:
    virtual
    void f(void)       cout << "C::f()" << endl;   

    void h(void)       cout << "C::g()" << endl;   

    void j(void)       cout << "C::j()" << endl;   
;


int main(void)

    C c;
    cout << "sizeof(A) = " << sizeof(A) << endl;

    A & a = c;
    a.f();
    a.g();
    a.h();
    cout << "-----------------" << endl;

    B & b = c;
    b.f();
    b.g();
    b.h();
    b.j();

    c.f();
    //c.g();
    c.h();
    c.j();

    return 0;

运行结果

sizeof(A) = 8
C::f()
A::g()
C::g()
/-----------------
C::f()
B::g()
B::h()
B::j()
/---------------
C::f()
C::g()
C::j()

由上面的代码可知，这里的多重继承虚函数指的就是C多重继承自A，B两个类；同时C也继承了A，B的虚函数表，如果C类中有定义覆盖A，B中的虚函数，则虚函数表中的虚函数将发生变化，将原来基类中的虚函数覆盖为派生类中的虚函数，这就表现了动态多态的性质。对于此类情况，把各种类的虚函数继承关系画出来，就一目了然。

以上是关于什么是多态性，C++中是如何实现多态的的主要内容，如果未能解决你的问题，请参考以下文章

C++中多态是怎样实现的？

c++实现多态一定要用指针吗

关于C++的多态实现机理问题

java中多态如何实现程序的可扩展性

C++多态实现原理

[C++]面向对象语言三大特性--多态