标签: multiple-inheritance

下面的代码示例,可以super使用,或者C有来电A.foo和B.foo明确？

class A(object):
    def foo(self):
        print 'A.foo()'

class B(object):
    def foo(self):
        print 'B.foo()'

class C(A, B):
    def foo(self):
        print 'C.foo()'
        A.foo(self)
        B.foo(self)

我没有C++经验,而且我来自Java背景.最近,我在接受采访时被问到为什么Java不允许多重继承,答案很简单.但是,我仍然很好奇C++如何处理它,因为它允许你从多个类继承.

具体来说,假设有一个叫做的类MechanicalEngineer,另一个叫做ElectricalEngineer.两者都有一个叫做的方法buildRobot().

如果我们制作第三个类会发生什么RoboticsEngineer,从两个方面都不存在并且不会覆盖该方法,并且您只需调用:

(some instance of RoboticsEngineer).buildRobot()

是否会抛出异常,或者使用其中一个超类的方法？如果是这样,编译器如何知道要使用哪个类？

我试图理解C++中继承顺序的影响..我在线查看,但我找不到一个明确而充分的答案......

所以,为了这个问题,假设有两个类:B类和C类.

现在,定义:

class A1 : public B, public C{ ... };
class A2 : public C, public B{ ... };

A1和A2有什么区别？

非常感谢!

所以,我认为代码可能解释了我想要做的比我言语更好,所以这里是:

import abc

class foo(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def bar(self):
        pass


class bar_for_foo_mixin(object):
    def bar(self):
        print "This should satisfy the abstract method requirement"


class myfoo(foo, bar_for_foo_mixin):
    def __init__(self):
        print "myfoo __init__ called"
        self.bar()

obj = myfoo()

结果:

TypeError: Can't instantiate abstract class myfoo with abstract methods bar

我正在尝试使用mixin类来满足abstract/interface类的要求.我错过了什么？

在python教程中,它说" Python支持有限形式的多重继承 ".

有什么限制？

谁能想到使用多重继承的任何情况？我能想到的每个案例都可以通过方法运算符来解决

AnotherClass() { return this->something.anotherClass; }

单继承很容易实现.例如,在C中,继承可以模拟为:

struct Base { int a; }
struct Descendant { Base parent; int b; }

但是对于多重继承,编译器必须在新构造的类中安排多个父类.怎么做？

我看到的问题是:父母应该安排在AB或BA中,还是以其他方式安排？然后,如果我做演员:

SecondBase * base = (SecondBase *) &object_with_base1_and_base2_parents;

编译器必须考虑是否更改原始指针.虚拟化需要类似的棘手的事情.

BI正在enable_shared_from_this我的代码中使用,我不确定它的用法是否正确.这是代码:

class A: public std::enable_shared_from_this<A>
{
public:
    void foo1()
    {
        auto ptr = shared_from_this(); 
    }
};

class B:public std::enable_shared_from_this<B>
{
public:
    void foo2()
    {
        auto ptr = shared_from_this(); 
    }
};

class C:public std::enable_shared_from_this<C>
{
public:
    void foo3()
    {
        auto ptr = shared_from_this(); 
    }
};

class D: public A, public B, public C
{
public:
    void foo()
    {
        auto ptr = A::shared_from_this(); 
    }
};

这些用法是否make_shared_from_this()正确,假设它们总是被shared_ptrD 调用？

我在我的代码中有一个场景,我想要一个类来实现两个不同类型的接口,比如这个例子:

interface Speaker<T> {
    fun talk(value: T)
}

class Multilinguist : Speaker<String>, Speaker<Float> {
    override fun talk(value: String) {
        println("greetings")
    }

    override fun talk(value: Float) {
        // Do something fun like transmit it along a serial port
    }
}

Kotlin对此不满意,引用:

Type parameter T of 'Speaker' has inconsistent values: kotlin.String, kotlin.Float
A supertype appears twice

我知道一个可能的解决方案是实现以下代码,我在其中实现接口,<Any>然后自己检查类型并将它们委托给它们的函数.

interface Speaker<T> {
    fun talk(value: T)
}

class Multilinguist : Speaker<Any> {
    override fun talk(value: Any) {
        when (value) {
            is String -> …

我知道一个类可以实现多个接口,但是可以扩展多个类吗？例如,我希望我的类扩展它TransformGroup和我创建的类.这在Java中可行吗？这两个语句class X extends TransformGroup extends Y并class X extends TransformGroup, Y收到一个错误.如果不可能,为什么？TransformGroup扩展,Group但我想它也扩展,Node因为它继承了字段Node,它可以传递到需要Node对象的地方.此外,与Java中的所有类一样,它们扩展了Object类.那么为什么不能用多个类扩展呢？

TransformGroup继承

那么,如果可能的话,做到这一点的正确方法是什么？如果没有,为什么以及如何解决问题呢？