标签: multiple-inheritance

我有两个Java接口和一个实现类.

(我已经使用Eclipse直接运行程序,并且我没有尝试通过从命令行显式编译来检查任何编译器警告等.)

为什么他们没有问题？为什么Java允许这样做,即使它满足两个接口的"契约"但是在实现类时产生歧义？

更新了示例.

public interface CassettePlayer {
    void play();
}

public interface DVDPlayer {
    void play();
}

public class CarPlayer implements CassettePlayer,DVDPlayer{

    @Override
    public void play() {
        System.out.println("This plays DVD, screw you Cassette !");
    }

    public static void main(String args[]) {
        CarPlayer cp = new CarPlayer();
        cp.play();

        CassettePlayer firstInterface = new CarPlayer();
        firstInterface.play();

        DVDPlayer secondInterface = new CarPlayer();
        secondInterface.play();
    }
}

请考虑以下代码:

trait A {
  def work = { "x" }
}

trait B {
  def work = { 1 }
}

class C extends A with B {
  override def work = super[A].work
}

类C不会在scala 2.10中编译,因为"在类型=> String的特征A中重写方法工作;方法工作具有不兼容的类型".

如何选择一种具体方法？

是否有任何课程typing表现得像混合？

例如

from typing import Union
class A:
  pass

class B:
  pass

class C:
  pass

class D(A, B, C):
  pass

# current: ab is A or B, but not both
def f(ab: Union[A, B]):
    pass

# ideal: ab is A and B
def f(ab: Mixin[A, B]):
    pass

f(D())

请注意如何D是A和的实例B,但也C.这对于f(因为f不需要C)限制太多,因此,参数ab不一定是类型D而是Mixin[A, B]

如果typing模块没有提供任何选项,有没有比创建自己更优雅的东西class AB(A, B)？

我有一节课:

class Base;

我也有一个界面

class Interface;

接下来我正在创建一个课程

class Derived : public Base, public Interface;

如果我有 Base *object = new Derived;

我怎么能投object给Interface？(当然,如果我知道对象实际上是派生类)

编辑:

我尝试过dynamic_cast和static_cast(未编译).那么让我解释一下这个问题:

我有:

class Object {...}

class ITouchResponder
{
public:
    virtual bool onTouchBegan(XTouch *touch) = 0;
    virtual void onTouchMoved(XTouch *touch) = 0;
    virtual void onTouchEnded(XTouch *touch) = 0;
};

class Ball : public Object, public ITouchResponder {...};

class TentacleSensor : public Object, public ITouchResponder {...}

对象有一个bool touchable_属性.如果它是真的那么对象正在实现ITouchResponder接口.

当我使用它时:

bool Level::onTouchBegan(XTouch *touch)
{
    ... …

我们假设有这样的类层次结构:

class A //base class

class B //interface

class C : public A, public B

然后创建C对象:

A *object = new C();

可以将对象转换为B吗？

重要提示:我假设我不知道该对象是C.我只知道它实现了接口B.

在C++中使用纯虚方法进行虚拟接口时,当具体类派生自两个具有相同方法声明的"接口"时会发生什么？例如X亚类Iaaa和Ibbb并实现方法virtual void setVisible(bool);.

难道事实Iaaa并Ibbb没有方法体使事情更容易/比一个更经典的菱形继承的情况下,并让X::setVisible 是两者的实施Iaaa::setVisible和Ibbb::setVisible？

我想更多C++方式的问题是"当一个类使用MI从两个具有相同签名的纯虚拟方法的类派生时会发生什么".

我有一个Derived直接从两个基类继承的类,Base1和Base2.我想知道一般来说,将指针与基类进行比较以确定它们是否是同一个Derived对象是否安全:

Base1* p1;
Base2* p2;

/*
 * Stuff happens here. p1 and p2 now point to valid objects of either their
 * base type or Derived
 */

//assert(p1 == p2); //This is illegal
assert(p1 == static_cast<Base1*>(p2)); //Is this ok?
assert(static_cast<Derived*>(p1) == static_cast<Derived*>(p2)); //How about this?

指针保证有效,但不一定指向Derived对象.我的猜测是这可能很好,但我想从技术C++的角度来看它是否可以.我实际上从不对指针进行任何操作,我只是想知道它们是否指向同一个对象.

编辑:如果我可以保证p1并p2指向Derrived对象似乎是安全的.我基本上想知道如果它们不是 - 如果一个或两个都指向基础对象,它是否安全,那么比较是否必然会失败？同样,我可以保证指针有效(即,p1永远不会指向Base2对象,反之亦然)

最近我参加了一次C++技术访谈:在那次采访中我问了一个我无法回答的问题:即使我尝试上网和一些论坛但无法得到答案,请参阅下面的代码片段:

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() …

我正在阅读"在C++对象模型中",试图了解如何通过vtable实现多重和虚拟继承.(我完全理解单个多态性).

我很难理解在虚拟继承期间或在转换期间需要定位方法时究竟做了什么,因为要执行大量的偏移计算.

有人能够帮助理解如何在多个或虚拟继承示例中使用多个vtable吗？如果我能理解布局和问题,我可能会更好地理解这个问题.

现在,我正在学习C++中的继承功能,并希望测试最近学到的虚拟基类的概念.我尝试了以下简单的代码:

#include <iostream>

using namespace std;

class A
{
private:
    int m_value;
    string m_caller;
public:
    A(int p_value, string p_caller) : m_value{p_value}, m_caller{p_caller}
    {
        cout<<"Instantiating A via "<<m_caller<<endl;
    }
};

class B : virtual public A
{
private:
    int m_value;
public:
    B(int p_value1,int p_value2) : A{p_value1,"B"}, m_value{p_value2}
    {
        cout<<"Instantiating B."<<endl;
    }
};

class C : public B
{
public:
    C(int p_value1,int p_value2) : A{p_value1,"C"}, B(p_value1, p_value2)
    {
        cout<<"Instantiating C."<<endl;
    }
};

int main()
{
    C c1(1,2);
    return 0;
}

请注意B(p_value1, …