标签: multiple-inheritance

我有一个重叠的继承层次结构.系统了解可以是客户,提供商和代理商的人员.一个人必须属于这些类别中的一个,但可以属于两个或三个,即一个人可以同时是客户和提供者.

在数据库中,我认为问题已经解决,每个类一个表(Person,Client,Provider和Agent表)和一个外键,从子类表的主键到超类表的主键.(欢迎任何可能的改进:))

问题来自Java世界,我不知道将这个数据库设计映射到我的Java POJO的最佳方法.我有三种可能的问题解决方法:

• 一个名为Person的唯一类,具有子类中所有字段的并集.这将需要一个鉴别器字段,以便知道人类的类型.问题是,不是客户端但是提供者的Person将所有与客户端相关的字段设置为null.

• 一个名为Person的唯一类,包含子类的所有公共字段和三个"DTO-kind"属性,用于保存与每个子类相关的字段.这样我们只有一个或两个字段为null而不是数十

• Person的一个抽象类和七个子类,每个可能的三个子类组合,即Client,Provider,Agent,ClientProvider,ClientAgent ... ClientProviderAgent.:S(当然,每个人都有相应的接口)

这是一个webapp.我使用hibernate + spring和GWT作为UI

问题是:哪个是解决这个问题的最佳方法？

以下是多重继承中面临的钻石问题,

class Base {
 public:
  Base() {
    cout << "Empty Base constructor " << endl; 
  }
  Base(const string & strVar) { 
    m_strVar = strVar; 
    cout << m_strVar << endl;
  }
  virtual ~Base() {
    cout << "Empty Base destructor " << endl;
  }
  virtual const string & strVar() const { 
   return m_strVar; 
  }

  string m_strVar;
};

class Derived1: public virtual Base {
 public:
  Derived1() {
    cout << "Empty Derived1 constructor " << endl; 
  }
  Derived1(const string & strVar) : Base(strVar) { …

如何编写具有多重继承的复制构造函数？

B1并且B2是继承了D存在继承链中没有金刚钻.我需要编写一个复制构造函数,D以便它调用B1和的复制构造函数B2

我想避免在clone()这里写一篇文章

我想使用具体类提供的实现从接口实现纯虚方法，而不必从具体类显式调用该方法。例：

class InterfaceA{  
public:  
    virtual void foo() = 0;  
};

class InterfaceB:public InterfaceA{  
public:  
   virtual void bar() = 0;  
};

class ConcreteA : public InterfaceA{  
public:  
   virtual void foo(){}//implements foo() from interface  
};

class ConcreteAB: public InterfaceB, public ConcreteA{  
public:  
    virtual void bar(){}//implements bar() from interface  
};

在这种情况下，编译器要求在ConcreteAB类中实现foo（），因为InterfaceB没有实现它，并且它是从InterfaceA继承的。

有一种方法可以告诉编译器使用来自ConcreteA的实现，而无需使用调用ConcreteA :: foo（）的包装器？

这必须要么讨论,要么我非常愚蠢.有很多类似的线程,为什么C#没有MI,我已经走了最多.但我很想知道C#是否已经暗中支持它了.

由于.NET中的每个类型都来自于System.Object我可以编写一个类

Person : object { }

现在,如果我有

Employee : Person { }

不是真的吗

Employee : object, Person { }

1)Employee类是否已经从两个类继承？

这里存在多重继承的所有问题太对了吗？让我说我有这个:

Person : object
{
    new public Type GetType()
    {
        return null;
    } 
}

Employee : object, Person 
{ 

}

2)现在如果我打电话Employee.GetType()应该打电话Person.GetType()还是object.GetType()？困惑是对的.我觉得不是C#神奇地为object类提供某种继承优先级,因为它已经在 MI的情况下已经存在于许多语言中？

我熟悉的原则(例如,从这个答案 和这一个),当一个类有一个移动构造函数和/或移动赋值操作符,其默认的拷贝构造函数和拷贝赋值运算符将被删除.但是,在我看过的例子中,可以通过显式定义新的复制构造函数和赋值运算符来解决这个问题.

在我的特定情况下,我有一个类,它是通过C样式结构和模板类的联合继承派生的.复制和移动赋值运算符在模板中显式定义,而复制和移动构造函数在类本身中显式定义.换句话说,一切都是明确定义的,尽管并非都在同一个地方.这是一些示例代码:

typedef struct {
    int n;
} myStruct;

template <typename T> class myTemplate
{
public:
    // Default constructor
    myTemplate<T>() : t_n(nullptr) {}

    // Cannot create copy or move constructors in template, as cannot 
    // access the 'n' member directly

    // Copy assignment operator
    myTemplate<T> & operator=(const myTemplate<T> &source)
    {
        if (this != &source)
        {
            *t_n = *(source.t_n);
        }
        return *this;
    }

    //! Move assignment operator
    myTemplate<T> & operator=(myTemplate<T> &&source)
    {
        if (this != …

使用enabled_shared_from_this时似乎有一些边缘情况.例如:

提升shared_from_this和多重继承

可以在不需要enable_shared_from_this的情况下实现shared_from_this吗？如果是这样,它可以快速制作吗？

此代码无效：

struct Agent {};
struct DoubleAgent : public Agent, public Agent {};

因为：

> g++ -c DoubleAgent.cpp
DoubleAgent.cpp:2:43: error: duplicate base type ‘Agent’ invalid
 struct DoubleAgent : public Agent, public Agent {};
                                           ^

为什么？

我不认为这违反了继承的概念。如果一个类可以与基类具有is-a关系，那么它不应该与一个基类具有is-two-of-a关系吗？特别要考虑到这一点，因为C ++支持多种继承，所以一个类已经可以是多种不同的基本类型。

此外，所谓的菱形问题已经间接支持了这种情况，在该问题中，多个（不同的）基类可以从一个公共基类继承。

我在Wikipedia上找到了几句话，似乎暗示这是OO语言中的常见但非普遍性约束，可能仅是由于担心语法复杂性，并且是不受欢迎的约束：

Wikipedia：继承（面向对象编程）#Design约束

设计约束

在设计程序时广泛使用继承会施加某些约束。

例如，考虑一个Person类，其中包含一个人的姓名，出生日期，地址和电话号码。我们可以定义一个名为Student的Person子类，其中包含该人的平均成绩和所采取的课程，以及另一个名为Employee的Person子类，其中包含该人的职称，雇主和薪水。

在定义此继承层次结构时，我们已经定义了某些限制，但并非所有限制都可取：

• 单一性：使用单一继承，子类只能从一个超类继承。继续上面给出的示例，“人”可以是“学生”或“雇员”，但不能同时是两者。使用多重继承部分地解决了这个问题，因为然后可以定义一个从Student和Employee继承的StudentEmployee类。但是，在大多数实现中，它仍然只能从每个超类继承一次，因此，不支持学生有两个工作或在两个机构就读的情况。通过支持重复继承，Eiffel中可用的继承模型使之成为可能。

维基百科：多重继承＃缓解

C ++不支持显式的重复继承，因为没有办法限定要使用的超类（即，一个类在单个派生列表中出现多次（类Dog：公共动物，动物））。

我不同意该声明“ ...，因为没有办法限定要使用的超类”。编译器是否不能只允许对基本限定符进行某种索引，例如Animal[1]::method()（并且同样，也许允许将类定义中的重复折叠为struct DoubleAgent : public Agent[2] {};）？我认为没有任何问题，从语法和概念上来说这不是一个简单的解决方案吗？

我相信我已经找到了两种可能的解决方法，尽管我无法确定它们是否会在实际系统中正常工作，或者它们是否会导致无法解决的问题：

1：在基类上消除模板非类型参数的歧义。

template<int N> struct Agent {};
struct DoubleAgent : public …

   namespace NUnitTestAbstract
{
    public abstract class BaseTestClass1
    {
        public abstract void BaseTestClass1Method();
    }

    public abstract class BaseTestClass2 : BaseTestClass1
    {
        // not overriding BaseTestClass1Method, child classes should do
        public void SomeTestMethodA() { }

        public void SomeTestMethodB() { }
    }

    public abstract class BaseTestClass3 : BaseTestClass1
    {
        // not overriding BaseTestClass1Method, child classes should do
        public void SomeTestMethodX() { }

        public void SomeTestMethodY() { }
    }

    public class TestClass2A : BaseTestClass2
    {
        public override void BaseTestClass1Method()
        {
            // do stuff
        } …

我有Circle班级和Rectangle班级.我现在想要创建一个类FunnyObject,每个类由一个圆和两个矩形组成.

如果我这样做:

class FunnyObject:public Circle, public Rectangle, public Rectangle{
//How do I refer to each of the Rectangle classes?

}

我如何引用Rectangle类中的函数和变量,因为存在歧义？

此外,通常构造函数是:

FunnyObject::FunnyObject:Circle(arguments), Rectangle(arguments){
//....
}

构造函数如何看待我的情况？