C++ —— 多态-优快云博客

 class Person
    {
    public:
        virtual void print()
        {
            cout << "Person::全价" << endl;
        }
    };
     
    class Student : public Person
    {
    public:
        virtual void print()
        {
            cout << "Student::半价" << endl;
        }
    };
     
    void test(Person* ptr)    //传入的对象不同调用不同的虚函数
    {
        ptr->print();    //必须是基类的指针或引用调用虚函数
    }
    int main()
    {
        Student s;
        Person p;
     
        test(&p);
        test(&s);
        
        return 0;
    }

2.2虚函数的重写

派生类中有一个与基类完全相同的虚函数(返回值、函数名、参数)，但是定义是派生类想要的，这样的，称派生类完成了对基类虚函数的重写(覆盖)。

派生类的重写虚函数不一定非要加virtual关键字，因为基类被继承之后其虚函数依旧保持其原有的虚函数属性，但是这样的代码风格是不规范的。

  class Student : public Person
    {
    public:
        void print()    //不加virtual关键字也可以
        {
            cout << "Student::半价" << endl;
        }
    };

如果派生类没有对虚函数进行重写，那么派生类依然有基类原有的虚函数。

 class Student : public Person
    {
        //派生类没有重写基类的虚函数
        //那么派生类依然持有基类原有的虚函数
    };

虚函数重写的两个例外：

1.协变(基类虚函数和派生类虚函数的返回值不同)

基类虚函数可以返回任意具有继承关系的基类的指针或引用；派生类虚函数可以返回任意具有继承关系的派生类的指针或引用；前两者的返回值必须是同一个继承系统。

 class A
    {};
    class B : public A
    {};
     
    // 基类虚函数可以返回任意具有继承关系的基类的指针或引用
    class Person
    {
    public:
        virtual A* print()
        {
            cout << "Person::全价" << endl;
            return nullptr;
        }
    };
     
    // 派生类虚函数可以返回任意具有继承关系的派生类的指针或引用
    class Student : public Person
    {
    public:
        virtual B* print()
        {
            cout << "Student::半价" << endl;
            return nullptr;
        }
    };

2.派生类的析构函数与基类的析构函数构成重写关系

如果基类的析构函数是虚函数，那么派生类的析构函数无论是否带有virtual关键字都与基类的析构函数构成重写。其原因在于：在多态系统中，编译器会自动将基类和派生类的析构函数解析为同名的destructor()函数。必须让派生类的析构函数与基类的析构函数构成重写关系的原因如下段代码所示：

  class A
    {
    public:
        virtual ~A()
        {
            cout << "A::~A()" << endl;
        }
    };
     
    class B : public A
    {
    public:
        ~B()
        {
            cout << "B:~B()" << endl;
        }
    };
     
    int main()
    {
        // 如果基类和派生类的析构函数不构成多态系统
        // 那么在清理资源时就会产生内存泄漏
        A* pa = new A;
        A* pb = new B;
     
        delete pa;
        delete pb;
        return 0;
    }

2.3override和final

C++对重写的要求比较严格，我们可以借助override和final这两个关键字检测派生类是否完成对基类虚函数的重写。

1.final放在类名后面，表示此类不能被继承：

  class A final
    {};
     
  class B : public A    //错误，A类不能被继承
    {};

2.final修饰虚函数，表明该虚函数不能被重写：

  class Car {
    public:
        virtual void Drive () final
        {}
    };
     
    class Benz :public Car {
    public:
        virtual void Drive() //错误，此虚函数不能被重写
        {
            cout << "Benz-舒适" << endl;
        }
    };

3.override可以检查派生类虚函数是否完成对基类虚函数的重写：

 class Car {
    public:
        virtual void Drive () const
        {}
    };
     
    class Benz :public Car {
    public:
        // 报错，多余Drive函数，派生类没有正确重写
        virtual void Drive() override
        {}
    };

3.抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口
类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生
类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

 class Car
    {
    public:
        virtual void Drive() = 0;
    };
     
    class Benz :public Car
    {
    public:
    };
     
    int main()
    {
        Benz b;    //错误，Benz类没有完成基类纯虚函数的重写
        return 0;
    }

3.1接口继承和实现继承

普通成员函数的继承是一种实现继承，派生类继承了基类普通成员函数的所有东西(返回值、函数名、参数列表、函数定义)。虚函数的继承是一种接口继承，派生类只继承了基类虚函数的接口(返回值、函数名、参数列表)，其目的就是为了派生类能够对虚函数进行重写(即使没有对基类虚函数进行重写，派生类依然保持基类原有虚函数，这是特性)。

下面是一道练习题：

 // 下面程序输出结果是什么？
    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;
    }
    // A: A->0 B : B->1 C : A->1 D : B->0 E : 编译出错 F : 以上都不正确

解析：使用派生类指针p指向派生类对象，那么这是一次普通函数调用。调用的函数是基类继承到派生类的虚函数，但是派生类没有对此函数完成重写，所以调用func函数时的this指针是基类指针，是一次多态调用。这个基类指针指向的是派生类对象(外部new了一个派生类对象)，所以调用的是派生类重写之后的func函数，又因为接口继承，所以派生类的func函数的参数的缺省值为1，所以最终结果为B->1。

4.多态原理

4.1虚函数表

我们使用一段代码来引用出虚函数表：

 // 32位平台下，sizeof(Base)是多少？
    class Base
    {
    public:
        virtual void Func1()
        {
            cout << "Func1()" << endl;
        }
    private:
        int _b = 1;
    };
     
    int main()
    {
        cout << sizeof(Base) << endl;
        return 0;
    }

解析：如果没有Func1这个虚函数，那么答案绝对是4。但是这里的输出为8。其原因在于，类中的虚函数需要放到虚函数表中，一个含有虚函数的类至少有一个虚函数表的指针，虚函数表也称虚表。所以一个含有虚函数的类，不仅仅存放了成员变量，还存放了一个虚表指针。

我们使用更为复杂的代码往下分析：

 class Base
    {
    public:
        virtual void Func1()
        {
            cout << "Base::Func1()" << endl;
        }
        virtual void Func2()
        {
            cout << "Base::Func2()" << endl;
        }
        void Func3()
        {
            cout << "Base::Func3()" << endl;
        }
    private:
        int _b = 1;
    };
     
    class Derive : public Base
    {
    public:
        virtual void Func1()
        {
            cout << "Derive::Func1()" << endl;
        }
    private:
        int _d = 2;
    };
     
    int main()
    {
        Base b;
        Derive d;
        return 0;
    }

观察上图的监视列表可以得出以下结论：

1.派生类对象由两部分构成，一部分是自己的成员，另一部分是基类成员；派生类对象也有也有一个虚表指针，这个指针存放在基类部分当中。

2.基类对象和派生类对象虚表是不一样的，这里我们发现派生类完成了Func1的重写，所以派生类对象的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖。覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

3.非虚函数的函数地址不会放入虚表中。

4.虚函数表本质是一个存放虚函数指针的指针数组(函数指针数组)，一般情况这个数组以nullptr结尾(VS环境下，Linux可能不一样)。

5.派生类的虚函数表是怎样生成的？先将基类虚表内容拷贝一份至派生类的虚表当中(因为这两个虚表的地址不一样，所以可以断定派生类的虚表是自己生成的)。如果派生类完成了对某个虚函数的重写，就会将重写的虚函数的地址放入虚表的对应位置。派生类自己新增的虚函数会依照声明顺序增加到派生类虚表的后面。

4.2原理

 class Person
    {
    public:
        virtual void print()
        {
            cout << "Person::全价" << endl;
        }
    };
     
    class Student : public Person
    {
    public:
        virtual void print()
        {
            cout << "Student::半价" << endl;
        }
    };
     
    void test(Person& ptr)    //传入的对象不同调用不同的虚函数
    {
        ptr.print();    //必须是基类的指针或引用调用虚函数
    }
    int main()
    {
        Student s;
        Person p;
     
        test(p);
        test(s);
        
        return 0;
    }

为什么根据传入对象的不同就能调用不同的虚函数？无论基类的指针或引用绑定的对象是基类对象还是派生类对象，他们都是没有区别的(绑定到派生类对象时会发生切片动作)，所以在编译的时候无法确定基类的指针或引用到底绑定的是基类对象还是派生类对象中的基类部分，但是这是正确的，所以编译会通过。当需要调用虚函数时，根本无法确定调用的是哪个虚函数，所以只能在程序运行时去虚函数表当中找被调用虚函数的地址。此时无论基类指针或引用绑定的对象是谁，只需要根据虚表内容不同，调用不同的虚函数即可。

4.3静态绑定和动态绑定

1.静态绑定：静态绑定在程序编译阶段就确定了行为，也称静态多态，例如函数重载。

2.动态绑定：动态绑定在编译阶段无法确定行为，只能在程序运行期间根据具体类型调用具体的函数，也称动态多态。

5.单继承和多继承体系的虚函数表

5.1单继承体系的虚函数表

 class Base {
    public:
        virtual void func1() { cout << "Base::func1" << endl; }
        virtual void func2() { cout << "Base::func2" << endl; }
    private:
        int a;
    };
     
    class Derive :public Base {
    public:
        virtual void func1() { cout << "Derive::func1" << endl; }
        virtual void func3() { cout << "Derive::func3" << endl; }
    private:
        int b;
    };
     
    int main()
    {
        Derive d;
        return 0;
    }

观察监视窗口发现：派生类的虚函数表中并没有func3函数的地址。是不是前面的理论是错误的？

其实不然，我们可以将虚表内容打印出来：

  class Base {
    public:
        virtual void func1() { cout << "Base::func1" << endl; }
        virtual void func2() { cout << "Base::func2" << endl; }
    private:
        int a = 1;
    };
     
    class Derive :public Base {
    public:
        virtual void func1() { cout << "Derive::func1" << endl; }
        virtual void func3() { cout << "Derive::func3" << endl; }
    private:
        int b = 2;
    };
     
    typedef void (*VFPTR)();
     
    void print_VFtable(VFPTR vf[])
    {
        cout << "虚表地址:0x" << vf << endl;
        for (int i = 0; vf[i] != nullptr; i++)
        {
            printf("[%d]:0x%p->", i, vf[i]);
            vf[i]();
        }
        cout << endl;
    }
    int main()
    {
        Base b;
        Derive d;
        
        // 对象的前4/8个字节存放的是虚表指针
        VFPTR* vfb = (VFPTR*)(*(int*)&b);
        print_VFtable(vfb);
     
        VFPTR* vfd = (VFPTR*)(*(int*)&d);
        print_VFtable(vfd);
     
        return 0;
    }

结论：派生类新增的虚函数的地址会放入派生类的虚表中，但是监视窗口不能体现出来。

5.2多继承体系的虚函数表

 class Base1 {
    public:
        virtual void func1() { cout << "Base1::func1" << endl; }
        virtual void func2() { cout << "Base1::func2" << endl; }
    private:
        int b1;
    };
     
    class Base2 {
    public:
        virtual void func1() { cout << "Base2::func1" << endl; }
        virtual void func2() { cout << "Base2::func2" << endl; }
    private:
        int b2;
    };
     
    class Derive : public Base1, public Base2 {
    public:
        virtual void func1() { cout << "Derive::func1" << endl; }
        virtual void func3() { cout << "Derive::func3" << endl; }
    private:
        int d1;
    };
     
    typedef void (*VFPTR)();
     
    void print_VFtable(VFPTR vf[])
    {
        cout << "虚表地址:0x" << vf << endl;
        for (int i = 0; vf[i] != nullptr; i++)
        {
            printf("[%d]:0x%p->", i, vf[i]);
            vf[i]();
        }
        cout << endl;
    }
    int main()
    {
        Base1 b1;
        Base2 b2;
        Derive d;
        
        // 对象的前4/8个字节存放的是虚表指针
        VFPTR* vfb1 = (VFPTR*)(*(void**)&b1);
        print_VFtable(vfb1);    //打印b1对象的虚表
     
        VFPTR* vfb2 = (VFPTR*)(*(void**)&b2);
        print_VFtable(vfb2);    //打印b2对象的虚表
     
        VFPTR* vfd1 = (VFPTR*)(*(void**)&d);
        print_VFtable(vfd1);    //打印d对象的第一张虚表
     
        VFPTR* vfd2 = (VFPTR*)(*(void**)((char*)&d + sizeof(Base1)));
        print_VFtable(vfd2);    //打印d对象的第二张虚表
     
        return 0;
    }

结论：派生类重写虚函数时是对多个基类的虚函数重写；派生类自己定义的虚函数的地址存放在派生类的第一张虚表当中。

6.继承和多态常见面试问题

6.1概念考察

1. 下面哪种面向对象的方法可以让你变得富有( )
A: 继承 B: 封装 C: 多态 D: 抽象

答案：A。继承可以定义一个与其他类相似的一个新类，并且这两个类保持一定的联系。

    2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。
    A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定
     答案：D。多态(动态绑定)可以实现题目描述的效果。

    3. 面向对象设计中的继承和组合，下面说法错误的是？（）
    A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复
    用，也称为白盒复用
    B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动
    态复用，也称为黑盒复用
    C：优先使用继承，而不是组合，是面向对象设计的第二原则
    D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封
    装性的表现
     答案：C。优先应使用组合，因为组合并没有破坏原有类的封装性且耦合度较低。

4. 以下关于纯虚函数的说法,正确的是( )
A：声明纯虚函数的类不能实例化出对象

B：声明纯虚函数的类是虚基类

C：派生类必须实现基类的纯虚函数

D：纯虚函数必须是空函数

答案：A。B中的虚基类是虚继承的概念。

5.关于虚函数的描述正确的是()

A:派生类的虚函数与基类的虚函数具有不同的参数个数和类型

B:内联函数不能是虚函数

C:派生类必须重新定义基类的虚函数

D:虚函数可以是一个static型的函数

答案：B。虚函数的调用必须通过虚表，如果是内联函数就破坏了这个行为。D中的说法是错误的，因为static函数没有this指针。

    6. 关于虚表说法正确的是（）
    A：一个类只能有一张虚表
    B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
    C：虚表是在运行期间动态生成的
    D：一个类的不同对象共享该类的虚表
    答案：D。虚表也是存放在代码区的，与成员函数一样。

    7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（）
    A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
    B：A类对象和B类对象前4个字节存储的都是虚基表的地址
    C：A类对象和B类对象前4个字节存储的虚表地址相同
    D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表
    答案：D。B中虚基表的说法是错误的。

8. 下面程序输出结果是什么? （）

  #include<iostream>
        using namespace std;
        class A {
        public:
            A(const char* s) { cout << s << endl; }
            ~A() {}
        };
        class B :virtual public A
        {
        public:
            B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
        };
        class C :virtual public A
        {
        public:
            C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
        };
        class D :public B, public C
        {
        public:
            D(const char* s1, const char* s2, const char* s3, const char* s4) :B(s1, s2), C(s1, s3), A(s1)
            {
                cout << s4 << endl;
            }
        };
        int main() {
            D* p = new D("class A", "class B", "class C", "class D");
            delete p;
            return 0;
        }

A：class A class B class C class D B：class D class B class C class A
C：class D class C class B class A D：class A class C class B class D

答案：A。因为是菱形虚拟继承，所以A类成员是B类和C类共享的，所以B和C两个类其中任意一个去初始化A都不合适(它们两个的构造函数显示调用A的构造函数是因为或许在某个场景下需要单独实例化B或C的对象)，所以初始化A的任务只能放给D了。初始化列表的初始化顺序与声明顺序有关，很明显：D类是先继承B再继承C，而在继承B之前B已经继承A了，所以初始化顺序为，A->B->C->D。

9. 多继承中指针偏移问题？下面说法正确的是( )

 class Base1 { public: int _b1; };
        class Base2 { public: int _b2; };
        class Derive : public Base1, public Base2 { public: int _d; };
        int main(){
        Derive d;
        Base1* p1 = &d;
        Base2* p2 = &d;
        Derive* p3 = &d;
        return 0;
        }

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3
答案：C。Derive类对象模型可以是下面这样：

10. 以下程序输出结果是什么（）

  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;
        }

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

答案：B。上面已经讲解过。

6.2问答题

1. 什么是多态？答：参考本篇博客内容。

2. 什么是重载、重写(覆盖)、重定义(隐藏)？答：参考本篇博客内容与上一篇继承博客。

3. 多态的实现原理？答：参考本篇博客内容。

4. 虚函数可以声明为inline函数吗？答：可以，不过编译器会忽略内联属性，因为虚函数不能做内联函数(inline是一个建议选项)。

5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类作用域限定符直接访问函数无法访问虚表(通过指针运算访问)，所以静态成员函数不能被放进虚表。

6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以。在继承体系中，外部有动态释放的资源时。

8. 对象访问普通函数快还是虚函数更快？答：如果非多态调用，二者一样快；如果是多态调用，虚函数的访问比普通函数慢，因为调用虚函数需要经过虚表。

9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

10. C++菱形继承的问题？虚继承的原理？答：参考继承博客。注意虚基表是虚继承的概念，虚基表存放的是偏移量；虚表是多态的概念，存放的是虚函数的地址。

11. 什么是抽象类？抽象类的作用？答：参考本篇博客内容。
————————————————
版权声明：本文为优快云博主「小龙向钱进」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/weixin_59913110/article/details/128959495