标签: virtual-inheritance

class Temp
{
private:
    ~Temp() {}
    friend class Final;
};

class Final : virtual public Temp
{
public:
     void fun()
     {
         cout<<"In base";
     }
};

class Derived : public Final
{
};

void main()
{
    Derived obj;
    obj.fun();
}

上面的代码试图实现不可继承的类(final).但是使用上面的代码仍然可以创建派生的对象,为什么呢？

只有当ctor私有化时才能实现所需的功能,我的问题是为什么在dtor私有的情况下无法实现？

我理解C++虚拟继承的基础知识.但是,我很困惑我需要在virtual复杂的类层次结构中使用关键字.例如,假设我有以下类:

            A
           / \
          B   C
         / \ / \
        D   E   F
         \ / \ /
          G   H
           \ /
            I

如果我想确保在任何子类中都没有出现过多次类,那么需要标记哪些基类virtual？他们都是？或者只在那些直接从一个类派生的类上使用它就足够了,否则这个类可能有多个实例(即B,C,D,E和F;以及G和H(但只有基类E,而不是基类D和F))？

为什么在编译器下面的代码中抱怨这PureAbstractBase是一个模糊的基类MultiplyInheritedClass？我意识到我有两个PureAbstractBasein MultiplyInheritedClass和that的副本,FirstConreteClass并且SecondConreteClass应该实际上派生,因为它们是钻石的中间行(这确实解决了下面代码的问题).但即使我有两个接口副本,为什么代码中的代码MultiplyInheritedClass不仅仅覆盖它们并且明确地选择了定义的接口类MultiplyInheritedClass？

#include <iostream>
using namespace std;

class PureAbstractBase {
  public:
    virtual void interface() = 0;
};

// I know that changing the following line to:
// class FirstConcreteClass : public virtual PureAbstractBase {
// fixes the problem with this hierarchy
class FirstConcreteClass : public PureAbstractBase {
  public:
    virtual void interface() { implementation(); }
  private:
    void implementation() { cout << "This is object FirstConcreteClass\n"; } …

什么是C++ 98/C++ 03标准'和C++ 0x未来标准的虚拟继承优势的确切规则？

我不是只要求具体的段落,虽然我也要求它(在第10节的某个地方,我猜).

我还要问,标准清楚地说明了标准的后果.

考虑以下层次结构

struct A {
   int a; 
   A() { f(0); }
   A(int i) { f(i); }
   virtual void f(int i) { cout << i; }
};
struct B1 : virtual A {
   int b1;
   B1(int i) : A(i) { f(i); }
   virtual void f(int i) { cout << i+10; }
};
struct B2 : virtual A {
   int b2;
   B2(int i) : A(i) { f(i); }
   virtual void f(int i) { cout << i+20; }
};
struct C : B1, virtual …

我在阅读c ++中的虚拟继承时在网站上发现了这个

使用多重继承时,有时需要使用虚拟继承.一个很好的例子是标准的iostream类层次结构:

//Note: this is a simplified description of iostream classes

class  ostream: virtual public ios { /*..*/ }
class  istream: virtual public ios { /*..*/ }

class iostream : public istream, public ostream { /*..*/ } 
//a single ios inherited

C++如何确保只存在虚拟成员的单个实例,而不管从中派生的类的数量是多少？C++使用额外的间接级别来访问虚拟类,通常是通过指针.换句话说,iostream层次结构中的每个对象都有一个指向ios对象的共享实例的指针.额外的间接级别有轻微的性能开销,但这是一个很小的代价.

我对声明感到困惑:

C++使用额外的间接级别来访问虚拟类,通常是通过指针

任何人都能解释一下吗？

我有一个基类和派生的基本类,我想更改基本函数,同时保持它们是静态的,因为它们应该作为静态传递给其他函数.

我怎样才能做到这一点？

给定以下代码(没有虚拟继承):

class A
{
public:
    virtual void f() = 0;
};

class B : public A
{
 public:
    virtual void f() {}
};

class C : public A
{
 public:
    virtual void f() {}
};

class D : public B, public C
{

/* some code */
};


int main()
{
    D d;
    return 0;
}

代码编译.

另一方面,这里:

class A
{
public:
    virtual void f() = 0;
};

class B : virtual public A
{
    virtual void f() {}
}; …

有没有(实用的)绕过普通(虚拟)构造函数调用顺序的方法？

例:

class A
{
    const int i;

public:
    A()
      : i(0)
    { cout << "calling A()" << endl; }

    A(int p)
      : i(p)
    { cout << "calling A(int)" << endl; }
};

class B
    : public virtual A
{
public:
    B(int i)
      : A(i)
    { cout << "calling B(int)" << endl; }
};

class C
    : public B
{
public:
    C(int i)
      : A(i), B(i)
    { cout << "calling C(int)" << endl; }
};

class D
    : public C …

我有类的钻石层次结构:

    A
  /   \
 B     C
  \   /
    D

为了避免D中的两个A副本,我们需要在B和C使用虚拟继承.

class A                     {  }; 
class B: virtual public A {};
class C: virtual public A   { }; 
class D: public B, public C { }; 

问题:为什么需要在B和C上执行虚拟继承,即使模糊度在D？如果它在D处会更直观.

为什么标准委员会将此功能设计为这样？如果B和C类来自第三方库,我们该怎么办？

编辑:我的回答是指示B和C类,只要它的派生对象被创建,它们就不应该调用A的构造函数,因为它将被D调用.