标签: virtual-inheritance

我知道基类的虚拟继承在多个派生类之间创建了一个公共共享基类,从而解决了DDD问题.如果我的基类只有一个派生类,那么当我虚拟地或非虚拟地继承基础时会有区别吗？基本上我试图理解查询中提供的解释是否有可能禁止在编译时从类派生？其中,Usage_lock基类是虚拟继承的,以防止从类Usable派生.如果我删除此虚拟键,行为会更改,即我可以从Usable派生子类.所以我想了解单继承场景中虚拟键的差异原因.

以下代码崩溃（访问冲突错误），因为我使用了虚拟继承。
AFAIK 虚拟继承通过强制使用类的单个实例来解决 Diamond 问题。在这种情况下，该类Derived仅继承了一个实例，IObject因此应该没有问题，但它会崩溃。

class IObject
{
public:
    virtual int getType()=0;
};
class Base : public IObject
{
protected:
    int val;
public:
    Base() { val = 1; }
    virtual int getType();
};
int Base::getType() { return val; }

class Derived : public virtual Base //If I remove the virtual keyword here problem is solved.
{
public:
    Derived() { val = 2; }
};

int getVal( void* ptr ) 
{
    return ((IObject*)ptr)->getType();
}

int main()
{ …

与继承虚拟功能不同,解析虚拟继承似乎是枯燥无味的,但也许我只是没有创造力(狡猾？).

虚拟继承是否与虚函数的继承有关？具体来说,虚拟继承是否会引发后期绑定？我看不出任何理由.由于关键字过载,我只是怀疑.

我意识到标准没有指定虚拟继承的实现.我对大多数非假想的机器都感兴趣,但不完美.

在处理虚拟继承时遇到这个问题.我记得在非虚拟继承层次结构中,子类的对象拥有其直接超类的对象.那么虚拟继承呢？在这种情况下,子类的对象是直接拥有其超类的对象还是仅仅持有一个指向其超类对象的指针？

顺便说一下,为什么以下代码的输出是:

sizeof(A): 8
sizeof(B): 20
sizeof(C): 20
sizeof(D): 36

码:

#include <iostream>

using namespace std;

class A{
    char k[ 3 ];
    public:
        virtual void a(){};
};

class B : public virtual A{
    char j[ 3 ];
    public:
        virtual  void b(){};
};

class C : public virtual A{
    char i[ 3 ];
    public:
        virtual void c(){};
};

class D : public B, public C{
    char h[ 3 ];
    public:
        virtual void d(){};
};

int main( int argc, char *argv[] ){ …

我有以下代码:

class A
{
};

class B: public virtual A
{
public:
    B()
    {
        cerr << "B()";
    }
    B(const A& a)
    {
        cerr << "B(const A&)";
    }
};

class C: public B
{

};

int main(int argc, char **argv)
{
    B *b = new B(C());
}

令我惊讶的是,B(const A&a)没有被调用.这是为什么？

我有以下两个接口,它们不是继承层次结构的一部分.然后我有两个具体的类,一个来自另一个.

class ICar {
    public:
    virtual void drive() = 0;
};

class IFastCar {
    public:
    virtual void drive() = 0;
    virtual void driveFast() = 0;
};

class Car : public virtual ICar {
    public:
    void drive() {};
};

class FastCar : public Car, public virtual IFastCar {
    public:
    void driveFast() {};
};

int main()
{
    FastCar fc;
    fc.drive();
    fc.driveFast();
    return 0;
}

当我编译时,我收到以下错误:

error: cannot declare variable `fc' to be of type `FastCar'
error:   because the following virtual functions are …

可能重复:
虚拟对象大小

虚拟继承是否会更改派生类的大小？我执行了以下代码,其中有两个派生类,一个是虚拟继承的,另一个是非虚​​拟继承的:

class A {
 public:
int a;
  virtual void a1();
};


class non_vir_der: public A{
 public:
int c;
  virtual void aa();
};


class vir_der: public virtual A{
public:
int d;
virtual void bb();
};

int main()
{
cout<<sizeof(non_vir_der)<<"\n";
cout<<sizeof(vir_der)<<"\n";
return 0;
}

输出:

12(imo:4(int a)+ 4(int c)+ 4(vir ptr))

16(额外4？)

再次检查我是否错过了什么,我尝试了所需的最小代码,删除了类中的所有整数,输出为:

4

4

第二个输出表明两个派生类的大小相同.为什么第一次运行中的vir_der 16的大小,为什么不是12？

这是给定程序的输出:

sizeof(Empty) 1
sizeof(Derived1) 1
sizeof(Derived2) 4
sizeof(Derived3) 1
sizeof(Derived4) 8
sizeof(Dummy) 1

这是该计划:

#include <iostream>
using namespace std;

class Empty
{};

class Derived1 : public Empty
{};

class Derived2 : virtual public Empty
{};

class Derived3 : public Empty
{    
    char c;
};

class Derived4 : virtual public Empty
{
    char c;
};

class Dummy
{
    char c;
};

int main()
{
    cout << "sizeof(Empty) " << sizeof(Empty) << endl;
    cout << "sizeof(Derived1) " << sizeof(Derived1) << endl;
    cout …

class ClassSealer {
private:
   friend class Sealed;
   ClassSealer() {}
};
class Sealed : public ClassSealer
{ 
   // ...
};
class FailsToDerive : public Sealed
{
   // This class is capable of being instantiated
};

以上未能封上课,但以下作品,为什么？

class ClassSealer {
private:
   friend class Sealed;
   ClassSealer() {}
};
class Sealed : public virtual ClassSealer
{ 
   // ...
};
class FailsToDerive : public Sealed
{
   // Cannot be instantiated
};

这里发生了什么？虚拟继承在这里发挥了什么作用？

我必须添加两种类型的图形项(QGraphicsRectItem和QGraphicsEllipseItem)的倍数QGraphicsScene(添加到QGraphicsView).每个图形项都应该能够与鼠标和键盘事件进行交互.所以最初我设计的课程如下.

初步设计:

class myQGraphicsRectItem : public QGraphicsRectItem
{
public:
    explicit myQGraphicsRectItem();
private:
    void mousePressEvent(QGraphicsSceneMouseEvent *event);
    void keyPressEvent(QKeyEvent *event);
    void focusOutEvent(QFocusEvent *event);
    //Many events goes here
    void fnCreateRect();
};

class myQGraphicsRectItem : public QGraphicsEllipseItem
{
public:
    explicit myQGraphicsRectItem();
private:
    void mousePressEvent(QGraphicsSceneMouseEvent *event);
    void keyPressEvent(QKeyEvent *event);
    void focusOutEvent(QFocusEvent *event);
    //Many events goes here
   void fnCreateCircle();
};

要知道如何避免重复事件声明和定义,我会阅读以下答案:

• 多重继承模糊调用
• 模板只能在头文件中实现？
• 虚拟基类

最后设计了如下课程.

改良设计:

头文件

template <class T>
class myQGraphicsRectItem : public QGraphicsRectItem , public QGraphicsEllipseItem{ …