multiple-inheritance

问题 Do interfaces solve the deadly diamond of death problem? I don't think so, for example: // A class implementing two interfaces Interface1 and Interface2. // Interface1 has int x=10 and Interface2 has int x = 20 public class MultipleInterface implements Interface1, Interface2{ public void getX(){ System.out.println(x); } } Here we get an ambiguous x . Though interfaces are a good way for solving method ambiguity, I guess they fail in the case of variables? Am I correct? If I am missing

问题 The following code doesn't work in Python 3.x, but it used to work with old-style classes: class Extender: def extension(self): print("Some work...") class Base: pass Base.__bases__ += (Extender,) Base().extension() Question is simple: How can I add dynamically (at runtime) a super class to a class in Python 3.x? But I'm ready the answer will be hard! ) 回答1: As for me it is impossible. But you can create new class dynamically: class Extender(object): def extension(self): print("Some work...")

问题 I'm trying to find a good example for the use of multiple inheritance what cannot be done with normal interfaces. I think it's pretty hard to find such an example which cannot be modeled in another way. Edit: I mean, can someone name me a good real-world example of when you NEED to use multiple inheritance to implement this example as clean as possible. And it should not make use of multiple interfaces, just the way you can inherit multiple classes in C++. 回答1: The following is a classic:

问题 This is our ideal inheritance hierarchy: class Foobar; class FoobarClient : Foobar; class FoobarServer : Foobar; class WindowsFoobar : Foobar; class UnixFoobar : Foobar; class WindowsFoobarClient : WindowsFoobar, FoobarClient; class WindowsFoobarServer : WindowsFoobar, FoobarServer; class UnixFoobarClient : UnixFoobar, FoobarClient; class UnixFoobarServer : UnixFoobar, FoobarServer; This is because the our inheritance hierarchy would try to inherit from Foobar twice, and as such, the compiler

问题 Single inheritance is easy to implement. For example, in C, the inheritance can be simulated as: struct Base { int a; } struct Descendant { Base parent; int b; } But with multiple inheritance, the compiler has to arrange multiple parents inside newly constructed class. How is it done? The problem I see arising is: should the parents be arranged in AB or BA, or maybe even other way? And then, if I do a cast: SecondBase * base = (SecondBase *) &object_with_base1_and_base2_parents; The compiler

问题 In The C# Programming Language Krzysztof Cwalina states in an annotation: we explicitly decided not to add support for multiple inheritance [...] the lack of multiple inheritance forced us to add the concept of interfaces, which in turn are responsible for problems with the evolution of the framework, deeper inheritance hierarchies, and many other problems. Interfaces are a core concept to OO programming languages. I don't follow the meaning of "forced us to add the concept of interfaces"

问题 I'm just diving into some more advanced python subjects (well, advanced to me at least). I am now reading about multiple inheritance and how you can use super(). I more or less understand the way the super function is used, but (1) What's wrong with just doing it like this ?: class First(object): def __init__(self): print "first" class Second(object): def __init__(self): print "second" class Third(First, Second): def __init__(self): First.__init__(self) Second.__init__(self) print "that's it"

问题 I'm trying to implement a Clonable class with the CRTP. However, I need to have abstract class that have a pure virtual clone method, overridden by child classes. To make this happen, I need the clone function to return a covariant return type. I made this code below, and the compiler shout at me this error: main.cpp:12:5: error: return type of virtual function 'clone' is not covariant with the return type of the function it overrides ('B *' is not derived from 'AbstractClonable *') The class

问题 I'm trying to implement a Clonable class with the CRTP. However, I need to have abstract class that have a pure virtual clone method, overridden by child classes. To make this happen, I need the clone function to return a covariant return type. I made this code below, and the compiler shout at me this error: main.cpp:12:5: error: return type of virtual function 'clone' is not covariant with the return type of the function it overrides ('B *' is not derived from 'AbstractClonable *') The class

问题 I tried to map some classes using Entity Framework in TPC style and got the following error: Error: The type 'A' cannot be mapped as defined because it maps inherited properties from types that use entity splitting or another form of inheritance. Either choose a different inheritance mapping strategy so as to not map inherited properties, or change all types in the hierarchy to map inherited properties and to not use splitting. This error occurs when I use the following classes: public