继承，菱形继承，多态，虚继承、菱形虚拟继承

最新推荐文章于 2022-09-03 15:50:24 发布
最新推荐文章于 2022-09-03 15:50:24 发布
阅读量802 收藏 8
点赞数 1
分类专栏： 剑指offer c/c++ 文章标签： 继承 菱形继承 多态 虚拟继承
面的代码主要写了关于：
(1).继承和派生的关系
(2).6个默认函数的继承(拷贝，拷贝构造，赋值，析构，...)
(3).普通菱形继承
(4).多重虚继承
(5).多态
(6).虚表
(7).虚菱形继承
     其中涉及到了很多C++中的内容，如<重载，隐藏，覆盖>，<虚基类，虚函数>，<单继承，多继承（菱形继承）> 等等 
#ifndef INHERIT_H_  
#define INHERIT_H_  
#include <iostream>  
#include <string>  
using namespace std;  
  
//继承和派生  
  
//继承与派生类的关系  
namespace Relation  
{  
    class Person  
    { //基类  
    public:  
        void fun()  
        {}  
        void show()  
        {  
            cout << _name << endl;  
        }  
        ~Person()  
        {  
            cout << "~Person" << endl;  
        }  
    public:  
        string _name;  
    };  
  
    class Student :protected Person  
    { // 派生类  
    public:  
        void show()  
        {  
            cout << _name << " " << _id << endl;  
        }  
        ~Student()  
        {  
            cout << "~Student" << endl;  
            //~Person(); //不能手动调用  
            Person::~Person(); //这样才可以调用  
        }  
  
    public:  
        /* 将数据成员设置成public确实不符合封装的理念， 
        但是我们是在找规律，所以这样做可以在类外改变数据成员，易于观察变化*/  
        int _id;   
    };  
  
    void test()  
    {  
        Person p;  
        Student s;  
        Person* p1 = &p;  
        //Person* p2 = &s; //共有继承时可以,保护和私有继承时却不可以  
        //s->fun(); //保护或者私有继承的时候，s不能访问的东西，p2是可以访问的，不合逻辑  
        //p2->fun(); //effective c++ 中讲到的has_a关系  
  
        Person& p3 = p;  
        //Person& p4 = s; //共有继承时可以,保护和私有继承时却不可以  
  
        Student* s1 = (Student*)&p;  
        //s1->_id = 0; //该段不属于s1，不能访问（写），相当于是借来的  
        Student* s2 = &s;  
        Student& s3 = (Student&)p;  
        //s3._id = 0; //该段不属于s3,不能访问（写），相当于是借来的  
        Student& s4 = s;  
    }  
}  
  
  
//6个默认函数的继承  
namespace FUNC  
{  
    class Person  
    {  
    public:  
        Person(const char* str = "")  
            :_name(str)  
        {//构造函数  
            cout << "Person(const char* str = "")" << endl;  
        }  
        Person(const Person& p)  
            :_name(p._name)  
        {//拷贝构造函数  
            cout << "Person(const Person& p)" << endl;  
        }  
        Person& operator=(const Person& p)  
        {//赋值语句  
            if (this != &p)  
            {  
                _name = p._name;  
                cout << "Person& operator=(const Person& p)" << endl;  
            }  
            return *this;  
        }  
        ~Person()  
        {//析构函数  
            cout << "~Person" << endl;  
        }  
    public:  
        string _name;  
    };  
  
    class Student :public Person  
    {  
    public:  
        Student(const char* s = "", int id = 0)  
            :Person(s)  
            , _id(id)  
        {  
                cout << "Student(const char* s ,int id) " << endl;  
        }  
  
        Student(const Student& s)  
            :Person(s) //发生切片  
        {  
                _id = s._id;  
                cout << "Student(const Student& s)" << endl;  
        }  
  
        Student& operator=(const Student& s)  
        {  
            if (this != &s)  
            {  
                Person::operator=(s); //也会发生切片  
                _id = s._id;  
                cout << "Student& operator=(const Student& s)" << endl;  
            }  
            return *this;  
        }  
  
        ~Student()  
        {  
            cout << "~Student" << endl;  
            //~Person(); //不能手动调用  
            //Person::~Person(); //这样才可以调用  
        }  
    public:  
        void show()  
        {  
            cout << _name << " " << _id << endl;  
        }  
  
        int _id;  
    };  
  
    void test()  
    {  
        Person p("hello");  
        Student s1("hello world", 2);  
        Student s2(s1);  
        Student s3;  
        s3 = s2;  
    }  
}  
  
//多继承(菱形继承)  
namespace MULTIPLE_INHERITANCE  
{  
    class A  
    {  
    public:  
        void func_a()  
        {  
            cout << "A-func" << endl;  
        }  
  
        int a;  
    };  
  
    class B : virtual public A //继承A  
    {  
    public:  
        void func_b()  
        {  
            cout << "B-func" << endl;  
        }  
        int b;  
    };  
      
    class C :virtual public A //继承A  
    {  
    public:  
        void func_c()  
        {  
            cout << "C-func" << endl;  
        }  
        int c;  
    };  
      
    class D :public B, public C //继承B，C  
    {  
    public:  
        void func_d()  
        {  
            cout << "D-func" << endl;  
        }  
        int d;  
    };  
  
    void test()  
    {  
        A a;  
        B b;  
        C c;  
        D d;  
        /***************************************************************************************************/  
        //通过内存变化可分析，虚继承与普通继承的区别  
  
        //非虚基类  
        /*d.B::a = 1; 
        d.b = 2; 
        d.C::a = 3; 
        d.c = 4; 
        d.d = 5; 
        cout << sizeof(a) << endl; //4 
        cout << sizeof(b) << endl; //8 
        cout << sizeof(c) << endl; //8 
        cout << sizeof(d) << endl; //20 可以看出a被继承了两次 
        */  
        //虚基类  
        d.B::a = 1;  
        d.b = 2;  
        d.C::a = 3;  
        d.c = 4;  
        d.d = 5;  
        cout << sizeof(a) << endl; //4  
        cout << sizeof(b) << endl; //12 a，b，加上一个指向虚基类的指针（严格来说不是指针，只是偏移量）  
        cout << sizeof(c) << endl; //12 a，c，加上一个指向虚基类的指针（严格来说不是指针，只是偏移量）  
        cout << sizeof(d) << endl; //24 a b c d  
        /***************************************************************************************************/  
    }  
}  
  
//多重虚继承  
namespace MULTIPLE_MANY  
{  
    class A  
    {  
    public:  
        virtual void funA()  
        {  
            cout << "A-fun" << endl;  
        }  
        virtual void fun_A()  
        {  
            cout << "A-fun_A" << endl;  
        }  
  
        int a;  
    };  
  
    class B  
    {  
    public:  
        virtual void funB()  
        {  
            cout << "B-fun" << endl;  
        }  
        virtual void fun_B()  
        {  
            cout << "B-fun_B" << endl;  
        }  
  
        int b;  
    };  
  
    class C  
    {  
    public:  
        virtual void funC()  
        {  
            cout << "C-fun" << endl;  
        }  
        virtual void fun_C()  
        {  
            cout << "C-fun_C" << endl;  
        }  
  
        int c;  
    };  
  
    class D :public A, public B, public C  
    {  
    public:  
        virtual void funA()  
        {  
            cout << "D-funA" << endl;  
        }  
        virtual void funB()  
        {  
            cout << "D-funB" << endl;  
        }  
        virtual void funC()  
        {  
            cout << "D-funC" << endl;  
        }  
        virtual void funD()  
        {  
            cout << "fun-D" << endl;  
        }  
  
        int d;  
    };  
  
    typedef void(*Fun)();  
  
    void PrintVtable(int* PTable)  
    {  
        printf("虚表地址：%p\n", PTable);  
        for (int i = 0; PTable[i] != 0; ++i)  
        {  
            printf("第%d个虚函数:%p ", i, PTable[i]);  
            Fun p = (Fun)PTable[i];  
            p();  
        }  
        printf("\n");  
    }  
  
    void test()  
    {  
        D d;  
        d.a = 1;  
        d.b = 2;  
        d.c = 3;  
        d.d = 4;  
        //虚表A  
        int* Vtable1 = (int*)*(int*)(&d); //根据在内存中分布位置来转化  
        PrintVtable(Vtable1);  
        //虚表B  
        int* Vtable2 = (int*)*((int*)(&d) + sizeof(A) / 4); //根据在内存中分布位置来转化  
        PrintVtable(Vtable2);  
        //虚表C  
        int* Vtable3 = (int*)*((int*)(&d) + (sizeof(A)+sizeof(B)) / 4); //根据在内存中分布位置来转化  
        PrintVtable(Vtable3);  
    }  
}  
  
//多态  
namespace POLYMORPHISM  
{  
    class A  
    {  
    public:  
        void fun1() //隐藏  
        {  
            cout << "A-func-1" << endl;  
        }  
        virtual void fun2() //覆盖的条件需要注意  
        {  
            cout << "A-func-2" << endl;  
        }  
        virtual A* fun3()  
        {  
            cout << "A-func-3（协变）" << endl;  
            return this;  
        }  
        //*重载的条件：作用域必须相同*  
        //下面两个函数才构成重载  
        void fun4()  
        {  
            cout << "void fun4()" << endl;  
        }  
        void fun4(int a)  
        {  
            cout << "void fun4(int)重载" << endl;  
        }  
    private:  
        int a;  
    };  
  
    class B : public A //继承A  
    {  
    public:  
        int fun1()  
        {  
            cout << "B-func-1隐藏" << endl;  
            return 0;  
        }  
        virtual void fun2() //覆盖的条件需要注意  
        {  
            cout << "B-func-2覆盖" << endl;  
        }  
        virtual B* fun3()  
        {  
            cout << "B-func-3覆盖（协变）" << endl;  
            return this;  
        }  
    private:  
        int b;  
    };  
  
    void test()  
    {  
        A a;  
        B b;  
        A* p1;  
        p1 = &a;  
        cout << "隐藏" << endl;  
        a.fun1();  
        b.fun1();  
        cout << "重载" << endl;  
        p1->fun4();  
        p1->fun4(0);  
        cout << "隐藏和覆盖" << endl;  
        p1->fun1();  
        p1->fun2();  
        p1->fun3();  
        p1 = &b;  
        p1->fun1();  
        p1->fun2();  
        p1->fun3();  
    }  
}  
  
//虚表  
namespace VIRTUAL_FUNC  
{  
    class Base1 {  
    public:  
        virtual void f() { cout << "Base1::f" << endl; }  
        virtual void g() { cout << "Base1::g" << endl; }  
        virtual void h() { cout << "Base1::h" << endl; }  
  
    };  
  
    class Base2 {  
    public:  
        virtual void f() { cout << "Base2::f" << endl; }  
        virtual void g() { cout << "Base2::g" << endl; }  
        virtual void h() { cout << "Base2::h" << endl; }  
    };  
  
    class Base3 {  
    public:  
        virtual void f() { cout << "Base3::f" << endl; }  
        virtual void g() { cout << "Base3::g" << endl; }  
        virtual void h() { cout << "Base3::h" << endl; }  
    };  
  
    class Derive : public Base1, public Base2, public Base3 {  
    public:  
        virtual void f() { cout << "Derive::f" << endl; }  
        virtual void g1() { cout << "Derive::g1" << endl; }  
    };  
  
    typedef void(*Fun)(void);  
  
    void test()  
    {  
        Fun pFun = NULL;  
  
        Derive d;  
        int** pVtab = (int**)&d;  
  
        //Base1's vtable  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);  
        pFun = (Fun)pVtab[0][0];  
        pFun();  
  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);  
        pFun = (Fun)pVtab[0][1];  
        pFun();  
  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);  
        pFun = (Fun)pVtab[0][2];  
        pFun();  
  
        //Derive's vtable  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);  
        pFun = (Fun)pVtab[0][3];  
        pFun();  
  
        //The tail of the vtable  
        pFun = (Fun)pVtab[0][4];  
        cout << pFun << endl;  
  
        //Base2's vtable  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);  
        pFun = (Fun)pVtab[1][0];  
        pFun();  
  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);  
        pFun = (Fun)pVtab[1][1];  
        pFun();  
  
        pFun = (Fun)pVtab[1][2];  
        pFun();  
  
        //The tail of the vtable  
        pFun = (Fun)pVtab[1][3];  
        cout << pFun << endl;  
  
        //Base3's vtable  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);  
        pFun = (Fun)pVtab[2][0];  
        pFun();  
  
        //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);  
        pFun = (Fun)pVtab[2][1];  
        pFun();  
  
        pFun = (Fun)pVtab[2][2];  
        pFun();  
  
        //The tail of the vtable  
        pFun = (Fun)pVtab[2][3];  
        cout << pFun << endl;  
    }  
  
}  
  
//虚钻石继承  
namespace VIRTUAL_RING  
{  
    typedef void(*Func)();  //函数指针  
  
    void PrintVTable(int *VTable)  
    {  
        cout << "虚表地址：" << VTable << endl;  
        for (int i = 0; VTable[i] != 0; i++)  
        {  
            printf("第VTable[%d]是：OX%p->", i, VTable[i]);  
            Func p = (Func)VTable[i];  
            p();  
        }  
        cout << endl;  
    }  
  
    class A  
    {  
    public:  
        virtual void fun1()  
        {  
            cout << "A-func1" << endl;  
        }  
        virtual void fun2()  
        {  
            cout << "A-func2" << endl;  
        }  
  
        int a;  
    };  
  
    class B : virtual public A //继承A  
    {  
    public:  
        virtual void fun1()  
        {  
            cout << "B-func1" << endl;  
        }  
        virtual void fun3()  
        {  
            cout << "B-func3" << endl;  
        }  
  
        int b;  
    };  
  
    class C :virtual public A //继承A  
    {  
    public:  
        virtual void fun1()  
        {  
            cout << "C-func1" << endl;  
        }  
        virtual void fun4()  
        {  
            cout << "C-func4" << endl;  
        }  
  
        int c;  
    };  
  
    class D :public B, public C //继承B，C  
    {  
    public:  
        virtual void fun1()  
        {  
            cout << "D-func1" << endl;  
        }  
        virtual void fun5()  
        {  
            cout << "D-func5" << endl;  
        }  
        int d;  
    };  
  
    void test()  
    {  
        cout << "虚表A:" << endl;  
        A a;  
        int *fa1 = (int *)(*(int *)&a);  
        PrintVTable(fa1);  
  
        cout << "虚表B:" << endl;  
        B b;  
        int* fa2 = (int *)(*(int *)&b);  
        PrintVTable(fa2);  
        fa2 = (int *)*(int *)((char *)&b + sizeof(B)-sizeof(A));  
        PrintVTable(fa2);  
  
        cout << "虚表C:" << endl;  
        C c;  
        int* fa3 = (int *)(*(int *)&c);  
        PrintVTable(fa3);  
        fa3 = (int *)*(int *)((char *)&c + sizeof(C)-sizeof(A));  
        PrintVTable(fa3);  
  
        cout << "虚表D" << endl;  
        D d;  
        d.a = 1;  
        d.b = 2;  
        d.c = 3;  
        d.d = 4;    //记得打开调试找到&d，然后好好看看地址分配，便于下面的操作  
        //虚表1  
        int* fa4 = (int *)(*(int *)&d);  
        PrintVTable(fa4);  
        //虚表2  
        fa4 = (int*)*((int*)&d + sizeof(B) / 4 - 2); //根据在内存中的分布来转化  
        PrintVTable(fa4);  
        //虚表3  
        fa4 = (int*)*((int*)&b + (sizeof(B)+sizeof(C)) / 4 - 3); //根据在内存中的分布来转化  
        PrintVTable(fa4);  
  
        A* p;  
        p = &a;  
        p->fun1();  
        p->fun2();  
        p = &b;  
        p->fun1();  
        p->fun2();  
        p = &c;  
        p->fun1();  
        p->fun2();  
        p = &d;  
        p->fun1();  
        p->fun2();  
  
    }  
}  
  
#endif  


我这篇博客没有细说，知识将我研究它们关系以及特点的时候的代码给出来了，其实我也准备好好写出来的，我也整理了其中很多的内容，我将它们截图下来了，其中的一些图如下：


1.关于虚表：

1.虚表


2.普通菱形继承


3.菱形继承，虚继承


4.虚拟菱形继承




一米阳光 zs
关注
专栏目录
c++中的菱形继承与虚拟菱形继承
M_jianjianjiao
12-26 508
c++中的继承关系分为单继承和多继承 单继承：一个派生类只有一个基类 多继承：一个派生类不止有一个基类 在多继承的过程成容易造成二义性问题。 菱形继承是多继承中的一种复杂的情况。 菱形继承的有两个问题： 二义性：当使用A的数据时无法确定继承自B 还是 C 数据冗余：类D中会有两份类A的数据 先看一个菱形继承的例子 #include &lt;iostream&gt; using names...
菱形继承和虚继承
canvasa的博客
08-28 432
一、单继承和多继承 单继承：一个子类只有一个直接父类时，称这个继承为单继承。 多继承：一个子类有俩个或以上的直接父类时称这个继承关系为多继承。 单继承：可以有多个父类，但是只能由一个直接父类。示意图如下： 多继承示意图如下： 菱形继承示意图如下： 菱形继承对象模型：Assistant的对象中有两份Person成员，菱形继承存在数据冗余和二义性的问题。 菱形继承举例： class person { public: string _name; }; class studen
C++之菱形继承
weixin_34233679的博客
05-28 287
当我们谈C++时，我们谈些什么？封装，继承，多态。这是C++语言的三大特性，而每次在谈到继承时我们不可避免的要谈到一个很重要的问题——菱形继承。a.菱形继承是什么如上图，菱形继承即多个类继承了同一个公共基类，而这些派生类又同时被一个类继承。这么做会引发什么问题呢，让我们来看一段代码吧！#include<iostream> usingnam...
【C++】继承和多态之——菱形继承
Amazing
08-04 523
菱形继承的模型  菱形继承是c++中的一种多继承，它的继承关系模型如下图，因此被称为菱形继承。菱形继承中的问题 菱形继承中存在的问题 ——菱形继承是多继承，那么和单继承不同，可能会出现一些问题：如果Child_1,Child_2都对Father中fun1进行重写，共用一个虚表，此时就会发生冲突。这时就要（virtual）虚函数，这时Child_1,Child_2就会生成各自的虚表，互不影响。
探索c++的对象模型（二）：菱形继承的多态模型
呼的一声飞得好远好远
05-07 204
首先我们已经知道了多继承和单继承的对象模型接下来我们来看一个复杂的菱形继承菱形继承的多态继承#define _CRT_SECURE_NO_WARNINGS 1#include&lt;stdio.h&gt;#include&lt;iostream&gt;using namespace std;class A{public:      virtual void func1()     {       ...
leijicheng.rar_继承多态问题
09-19
当两个或多个基类有共同的祖先时，不使用虚拟继承可能会导致一个对象中有多个相同的基类副本，这称为菱形问题。通过声明基类为虚拟的，如 `class Derived : virtual public Base1, virtual public Base2 {}`，我们...
菱形虚拟继承详解
TerryZjl的博客
04-16 908
菱形继承是继承里面比较复杂的有一种，在这里我分别对菱形继承、菱形虚拟继承、菱形虚拟继承含虚函数这几种情况 要清楚虚表和虚基表是两个完全不同的概念 虚表：虚函数表，存的是虚函数->多态 虚基表：存的是偏移量，解决二义性和数据冗余性。 虚继承解决了在菱形继承里面子类对象包含多分父类对象的数据冗余现象和二义性。
C++多态（五）---菱形继承中的虚函数表详解
董皓宇
12-28 3376
C++多态 菱形继承 虚基表指针与虚基表 我们知道，在虚继承（菱形继承）中，对于类D创建的对象d，为了避免A类中的变量重复，所以，将A类中成员变量放在d对象模型的最下面，由B类与C类各自虚基表指针访问虚基表中偏移量的方式进行访问A类成员变量。 虚函数表指针与虚函数表（虚表） 在类中成员函数实现多态时，需要将成员函数定义为虚函数，所以，在多态的情景下，单继承下会存在一个虚函数表指针，指向成员函数...
C++继承详解三 ----菱形继承、虚继承
丁香枝上，豆蔻梢头
04-17 1089
今天呢，我们来讲讲菱形继承与虚继承。这两者的讲解是分不开的，要想深入了解菱形继承，你是绕不开虚函数这一点的。它俩有着什么关系呢？值得我们来剖析。 菱形继承也叫钻石继承，它是多继承的一种特殊实例吧，它的基本架构如下图： 在我们的设想中，D所对应的对象模型应该如下图所示： 下面我们来用一段代码验证一下： class A { public: A() { cout
C++ 多重继承和虚拟继承对象模型、效率分析
09-04
C++的多重继承和虚拟继承是面向对象编程中两种高级特性，它们允许类从多个基类继承特性，但同时也引入了复杂性和效率问题。本文主要探讨了这两种继承方式的基本概念，对象模型的差异，以及它们对运行效率的影响。 ...
菱形继承与虚拟继承
no_name_sky的博客
02-15 241
c++中的继承有单继承和多继承；本文主要探索的是多继承中菱形继承的二义性和数据冗余及解决方案； 菱形继承的对象模型：                                      从内存看菱形继承对象模型： 用一个简易 的代码来说明二义性和数据冗余这个问题： class AA{ public: int _aa; }; class BB : pu
菱形继承与菱形虚拟继承
hyb_91的博客
01-30 271
菱形继承 单继承：一个子类只有一个直接父类时称这个继承关系为单继承  多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承 菱形继承：菱形继承是多继承的一种特殊情况。    来看看下面这段菱形继承的代码有什么问题呢？ #include &lt;iostream&gt; class A { public: int a; }; class A1 : public A { ...
继承*菱形继承与菱形虚拟继承（上）
小葱的博客
02-27 2611
面向对象程序设计的核心思想是封装（数据抽象）、继承和多态（动态绑定）。 通过使用数据抽象，我们可以将类的接口与实现分离； 使用继承，可以定义相似的类型并对其相似关系建模； 使用动态绑定，可以在一定程度上忽略相似类型的区别，而用统一方式使用它们的对象。简单的说，继承的使用就是为了代码复用。 1.继承 ①继承机制：是为了扩展原有类，增加新的功能。 ②继承的定义格式： 子类名：
C++ 三大特性之继承(二)重点：菱形虚拟继承
weixin_57761086的博客
09-01 1346
C++普通多继承，普通菱形继承，普通虚拟继承，菱形虚拟继承，验证菱形虚拟继承的对象模型，验证普通菱形继承的对象模型，验证普通继承的对象模型。验证派生类的默认构造函数的规则。
复杂的菱形继承及菱形虚拟继承
didi1663478999的博客
09-26 248
复杂的菱形继承及菱形虚拟继承 单继承：一个子类的只有直接父类时称这个继承关系为单继承 多继承：一个子类有两个或两个以上直接父类称这种继承关系为多继承 菱形继承：菱形继承是多继承的一种特殊情况 菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题 class Person { public: string _name; }; class Student :pu...
【 C++ 】多态
bit_zyx的博客
09-03 1035
目录 1、多态的概念 2、多态的定义及实现 2.1、多态的构成条件 2.2、虚函数 2.3、虚函数的重写 虚函数重写的两个例外 2.4、C++11 override和final 2.5、重载、覆盖(重写)、隐藏(重定义)的对比 3、抽象类 概念 接口继承和实现继承 4、多态的原理 虚函数表 多态的原理 ...
C++继承与多态六：虚基类、虚继承、多重继承中菱形继承问题及解决方案
Rain的博客
03-15 649
文章目录一、虚基类和虚继承二、虚基类和虚继承出错情况分析三、菱形继承问题 一、虚基类和虚继承 虚基类:被虚继承的类，就称为虚基类。 virtual作用： 1.virtual修饰了成员方法是虚函数。 2.可以修饰继承方式，是虚继承。被虚继承的类就称为虚基类。 vfptr：一个类有虚函数，这个类生成的对象就有vfptr，指向vftable。 vbptr：在派生类中从基类虚继承而来。 vftable：第...
class学习（七）菱形继承，多态
wanxiangzx的博客
03-27 147
1.菱形继承 一个父亲，两个儿子，一个孙子又去继承两个儿子 2.解决菱形继承中数据重复继承问题 虚继承 virtual base Animal { public: int m_age; }； 使用开发人员命令提示工具发现SheepTuo中继承的m_age只有一份， 而从Sheep和Tuo继承下来的是vbptr virtual base pointer虚基类指针会指向vbtab......
C++菱形继承和菱形虚拟继承及虚拟继承的原理
Damn_Yang的博客
01-14 421
单继承：一个字类只有一个直接父类时称这个继承关系为单继承 多继承：一个字类有两个或以上直接父类时成这个继承关系为多继承 菱形继承：菱形继承是多继承的一种特殊情况 菱形继承的问题:从下面的对象成员模型构造，可以看出菱形继承有是数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。 class Person { public: string _nam...
C++多继承与虚拟基类的深入解析
在C++中，虚拟基类是为了解决多重继承中可能出现的菱形继承问题（即钻石继承问题）而设计的。在菱形继承中，子类通过两个或更多的基类间接继承同一个基类，导致间接基类被多次复制，从而产生数据冗余和逻辑错误。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值