c++菱形继承产生的问题及解决

#include<stdio.h>
#include<iostream>
#include<queue>
using namespace std;

class A {
public:
    A(){printf("A create.\n");}
    int a;
    virtual void fun(){}
};

class B: public A{
public:
    B(){printf("B create.\n");}
    int b;
    virtual void fun1(){}
};

class C: public A
{
public :
    int c;
    C(){printf("C create.\n");}
    virtual void fun3(){printf("fun3 .\n");}
};

class D:public C,public B{
public:
    int d;
    D(){printf("D create.\n");}
    virtual void fun3(){printf("fun4 .\n");}
}; 
//二义性问题的开销 
int main() {
    D *pd=new D;
    printf("%d\n",sizeof(D));
    getchar();
}

两个子类继承同一个父类,而又有子类又分别继承这两个子类, 会产生二义性问题,此时的继承关系是这样的:

   A           A
    |           |
   B          C
     \         /
         D

相当于baseClass A在类中有两个,这可能不是我们想要的结果,增加调用的困难,同时也会浪费内存资源。

那怎么解决这种问题呢?使用虚拟继承!

#include<iostream>
using namespace std;
class A{
public:
    A(char *s)
    {
        cout<<s<<endl;
    }
    ~A(){}
};
class B:virtual public A
{
public:
    B(char *s1,char*s2):A(s1){
        cout<<s2<<endl;
    }
};
class C:virtual public A
{
public:
    C(char *s1,char*s2):A(s1){
        cout<<s2<<endl;
    }
};
class D:public B,public C
{
public:
    D(char *s1,char *s2,char *s3,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;
}
此时, baseClass A是公用的,也就是baseClass A就实例化了一个对象!

        A
     /      \
   B       C
    \        /
        D
加了virtual后, 继承关系是这样的.

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++菱形继承是指一个派生类同时继承了两个直接或间接基类,而这两个基类又间接或直接继承自同一个基类,从而形成了一个菱形的继承关系。 例如下面的代码: ``` class A { public: int a; }; class B : public A { public: int b; }; class C : public A { public: int c; }; class D : public B, public C { public: int d; }; ``` 在这个例子,类 `D` 继承了类 `B` 和类 `C`,而类 `B` 和类 `C` 都继承了类 `A`,因此形成了一个菱形继承关系。 菱形继承会引起一些问题,例如: 1. 内存浪费:由于类 `A` 被重复继承,导致在内存存在两份相同的 `A` 对象,造成内存浪费。 2. 访问冲突:由于类 `D` 继承了类 `B` 和类 `C`,而这两个类都继承了类 `A`,因此在类 `D` 访问 `A` 的成员时会出现访问冲突的问题。 为了解决菱形继承带来的问题,可以使用虚继承。虚继承可以解决内存浪费和访问冲突的问题,它的原理是在派生类只保留一个虚基类的实例,由所有的派生类共享使用。 修改上面的例子,使用虚继承: ``` class A { public: int a; }; class B : virtual public A { public: int b; }; class C : virtual public A { public: int c; }; class D : public B, public C { public: int d; }; ``` 在这个例子,类 `B` 和类 `C` 继承类 `A` 时使用了 `virtual` 关键字,表示使用虚继承。这样,类 `D` 就只有一个 `A` 对象的实例,而且访问 `A` 的成员也不会出现访问冲突的问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值