防止C ++中的多重继承[重复]

Question

最近我参加了一个C++技术面试：面试官问了我一个问题，我没能回答：即使我在互联网和一些论坛上尝试过但无法得到答案，请看下面的代码sn-p ：

using namespace std;

class Base1
{
    public:
    Base1() 
    {
        cout << "Base1 constructor..." << endl;
    }

    ~Base1() 
    {
        cout << "Base1 Destructor..." << endl;
    }
};  

class Base2
{
public:
    Base2() 
    {
        cout << "Base2 constructor..." << endl;
    }

    ~Base2() 
    {
      cout << "Base2 Destructor..." << endl;  
    }
};

class Derived : public Base1, public Base2 
{
public:
  Derived()
  {
      cout << "Derived constructor...."  << endl;
  }
  ~Derived()
  {
      cout << "Derived Destructor..." << endl;
   }
};


int main()
{
   cout << "Hello World" << endl; 
   Base1 b1; Base2 b2;
   Derived d1;

   return 0;
}

说明：有两个名为 Base1 和 Base2 的基类和一个名为 Derived 的派生类。 Derived 是从 Base1 和 Base2 多重继承的。

问题：我希望 Derived 只能从一个类继承，而不是从两个类继承。如果开发人员将尝试从这两个类继承：那么应该会产生错误：让我总结一下：

• 场景 1：派生类：public Base1 // 好的。---> 没有错误
• 场景 2：派生类：public Base2 // 好的。---> 没有错误
• 场景 3：派生类：public Base1、public Base2 // 错误或异常或任何事情。无法继承。

注意：你能回答这个问题吗：我真的不确定这是否可行。还有一件事：这不是钻石问题。

谢谢。

Answer 1

运行时检查：

#include <iostream>
#include <stdexcept>
#include <typeinfo>

class B1 {
    protected:
    template <typename D>
    B1(D* d) {
        // The paranoid 'is_same' is preventing the cast (B1*)this in the derived constructor.
        if((void*)this != (void*)d || std::is_same< B1, D >::value)
            throw std::logic_error("Multiple Inheritance [1]");
    }

    int data;
};

class B2 {
    protected:
    template <typename D>
    B2(D* d) {
        // The paranoid 'is_same' is preventing the cast (B2*)this in the derived constructor.
        if((void*)this != (void*)d || std::is_same< B2, D >::value)
            throw std::logic_error("Multiple Inheritance [2]");
    }

    int data;
};


struct D : public B1, public B2 {
    D()
    :   B1(this), B2(this)
    {}
};

int main() {
    D d;
}

注意：如果类为空，这将不起作用。 不如@egur 的好主意。 不过，它的好处是不引入虚函数。

Answer 2

在具有不同返回类型的两个基中声明一个纯虚函数：

class B1 {
   virtual void a() = 0;
};

class B2 {
   virtual int a() = 0; // note the different return type
};

不可能从两者继承。

class D : public B1, public B2 {
public:
    // virtual void a() {} // can't implement void a() when int a() is declared and vice versa
    virtual int  a() {}
};

int main(void) {
    D d; // produces C2555 error
    return 0;
}

产生此错误：

• 错误 C2555：“D::a”：覆盖虚函数返回类型不同，并且与“B1::a”不协变
• 参见“B1::a”的声明

Answer 3

使用 Lai Yu-Hsuan 建议的方法，但给 Base0 一个纯虚函数，该函数必须被 Base1 和 Base2 覆盖。如果您尝试从 Base1 和 Base2 继承，编译器应该会抱怨函数不明确。 编辑：这不是下面迈克指出的正确答案

Answer 4

你可以用 C++11 做到这一点，看：

#include <type_traits>
struct Base1 {}; 
struct Base2 {}; 

struct Derived 
   : public Base1
  , public Base2
{ 
  Derived() 
  { 
     static_assert( !(std::is_base_of< Base1, Derived >::value && std::is_base_of< Base2, Derived >:: value), "You cannot inherit from both Base1 and Base2" ); 
  } 
}; 



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

仅当您从 Base1 或从 Base2 继承时，它才能工作和编译。 如果您尝试从两者继承，则无法编译。 如果您想要运行时错误，而不是编译时错误，您甚至可以使用相同的方法来检查它。试着玩这个 sn-p。

Answer 5

我能弄清楚的唯一方法是把这种情况变成钻石问题。

class Base1 : public Base0
class Base2 : public Base0

如果用户尝试从Base1 和Base2 继承，编译器会报错。