multiple-inheritance

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 would complain of ambiguous references on any members of Foobar . Allow me to explain why I want such

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 must consider whether to alter or not the original pointer. Similar tricky things are required with

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" On to super(), Andrew Kuchlings paper on Python Warts says: usage of super() will also be correct when

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" Does Krzysztof mean that certain design decisions had to be made regarding the use of interfaces where

I have three classes: A , B and C . C inherits from A and B (in this order). The constructor signatures of A and B are different. How can I call the __init__ methods of both parent classes? My endeavour in code: class A(object): def __init__(self, a, b): super(A, self).__init__() print('Init {} with arguments {}'.format(self.__class__.__name__, (a, b))) class B(object): def __init__(self, q): super(B, self).__init__() print('Init {} with arguments {}'.format(self.__class__.__name__, (q))) class C(A, B): def __init__(self): super(A, self).__init__(1, 2) super(B, self).__init__(3) c = C() yields