In [*Programming Python*][2], Mark Lutz mentions the term *mixin*. I am from a C/C++/C# background and I have not heard the term before. What is a mixin?

Reading between the lines of [this example][1] (which I have linked to because it is quite long), I am presuming it is a case of using multiple inheritance to extend a class as opposed to proper subclassing. Is this right?

Why would I want to do that rather than put the new functionality into a subclass? For that matter, why would a mixin/multiple inheritance approach be better than using composition?

What separates a mixin from multiple inheritance? Is it just a matter of semantics?

  [1]: http://books.google.com/books?id=5zYVUIl7F0QC&amp;pg=RA1-PA584&amp;lpg=RA1-PA584&amp;dq=programming+python+guimixin&amp;source=bl&amp;ots=HU833giXzH&amp;sig=jwLpxSp4m_VbOYQ897UDkGNx_2U&amp;hl=en&amp;ei=x8iRSaTTF5iq-ganpbGPCw&amp;sa=X&amp;oi=book_result&amp;resnum=3&amp;ct=result
  [2]: http://www.amazon.com/Programming-Python-Mark-Lutz/dp/0596009259/

What is a mixin and why is it useful?

How does `super()` work with multiple inheritance? For example, given:


    class First(object):
    	def __init__(self):
    		print &quot;first&quot;
    
    class Second(object):
    	def __init__(self):
    		print &quot;second&quot;
    
    class Third(First, Second):
    	def __init__(self):
    		super(Third, self).__init__()
    		print &quot;that&#39;s it&quot;

Which parent method of `Third` does `super().__init__` refer to? Can I choose which runs?

I know it has something to do with method resolution order ([MRO][1]). 

  [1]: http://en.wikipedia.org/wiki/C3_linearization


How does Python&#39;s super() work with multiple inheritance?

What&#39;s the difference between:

    class Child(SomeBaseClass):
    	def __init__(self):
    		super(Child, self).__init__()
    		
and:
    		
    class Child(SomeBaseClass):
    	def __init__(self):
    		SomeBaseClass.__init__(self)
    		
I&#39;ve seen `super` being used quite a lot in classes with only single inheritance. I can see why you&#39;d use it in multiple inheritance but am unclear as to what the advantages are of using it in this kind of situation.

What does &#39;super&#39; do in Python? - difference between super().__init__() and explicit superclass __init__()

Say I have a multiple inheritance scenario:

    class A(object):
        # code for A here

    class B(object):
        # code for B here

    class C(A, B):
        def __init__(self):
            # What&#39;s the right code to write here to ensure 
            # A.__init__ and B.__init__ get called?

There&#39;s two typical approaches to writing `C`&#39;s `__init__`:

 1. (old-style) `ParentClass.__init__(self)`
 2. (newer-style) `super(DerivedClass, self).__init__()`

However, in either case, if the parent classes (`A` and `B`) [don&#39;t follow the same convention, then the code will not work correctly](http://fuhm.org/super-harmful/) (some may be missed, or get called multiple times).

So what&#39;s the correct way again?  It&#39;s easy to say &quot;just be consistent, follow one or the other&quot;, but if `A` or `B` are from a 3rd party library, what then?  Is there an approach that can ensure that all parent class constructors get called (and in the correct order, and only once)?

Edit: to see what I mean, if I do:

    class A(object):
        def __init__(self):
            print(&quot;Entering A&quot;)
            super(A, self).__init__()
            print(&quot;Leaving A&quot;)
            
    class B(object):
        def __init__(self):
            print(&quot;Entering B&quot;)
            super(B, self).__init__()
            print(&quot;Leaving B&quot;)
    
    class C(A, B):
        def __init__(self):
            print(&quot;Entering C&quot;)
            A.__init__(self)
            B.__init__(self)
            print(&quot;Leaving C&quot;)

Then I get:

    Entering C
    Entering A
    Entering B
    Leaving B
    Leaving A
    Entering B
    Leaving B
    Leaving C

Note that `B`&#39;s init gets called twice.  If I do: 

    class A(object):
        def __init__(self):
            print(&quot;Entering A&quot;)
            print(&quot;Leaving A&quot;)
            
    class B(object):
        def __init__(self):
            print(&quot;Entering B&quot;)
            super(B, self).__init__()
            print(&quot;Leaving B&quot;)
    
    class C(A, B):
        def __init__(self):
            print(&quot;Entering C&quot;)
            super(C, self).__init__()
            print(&quot;Leaving C&quot;)

Then I get: 

    Entering C
    Entering A
    Leaving A
    Leaving C

Note that `B`&#39;s init never gets called.  So it seems that unless I know/control the init&#39;s of the classes I inherit from (`A` and `B`) I cannot make a safe choice for the class I&#39;m writing (`C`).

Calling parent class __init__ with multiple inheritance, what&#39;s the right way?

Since multiple inheritance is bad (it makes the source more complicated) C# does not provide such a pattern directly. But sometimes it would be helpful to have this ability.

For instance I&#39;m able to implement the missing multiple inheritance pattern using interfaces and three classes like that:

    public interface IFirst { void FirstMethod(); }
    public interface ISecond { void SecondMethod(); }

    public class First:IFirst 
    { 
        public void FirstMethod() { Console.WriteLine(&quot;First&quot;); } 
    }

    public class Second:ISecond 
    { 
        public void SecondMethod() { Console.WriteLine(&quot;Second&quot;); } 
    }

    public class FirstAndSecond: IFirst, ISecond
    {
        First first = new First();
        Second second = new Second();
        public void FirstMethod() { first.FirstMethod(); }
        public void SecondMethod() { second.SecondMethod(); }
    }

Every time I add a method to one of the interfaces I need to change the class *FirstAndSecond* as well. 

Is there a way to inject multiple existing classes into one new class like it is possible in C++? 

Maybe there is a solution using some kind of code generation?

Or it may look like this (imaginary c# syntax):

    public class FirstAndSecond: IFirst from First, ISecond from Second
    { }

So that there won&#39;t be a need to update the class FirstAndSecond when I modify one of the interfaces.

---

### EDIT
Maybe it would be better to consider a practical example:

You have an existing class (e.g. a text based TCP client based on ITextTcpClient) which you do already use at different locations inside your project.  Now you feel the need to create a component of your class to be easy accessible for windows forms developers.

As far as I know you currently have two ways to do this:

1. Write a new class that is inherited from components and implements the interface of the TextTcpClient class using an instance of the class itself as shown with FirstAndSecond.

2. Write a new class that inherits from TextTcpClient and somehow implements IComponent (haven&#39;t actually tried this yet).

In both cases you need to do work per method and not per class. Since you know that we will need all the methods of TextTcpClient and Component it would be the easiest solution to just combine those two into one class.

To avoid conflicts this may be done by code generation where the result could be altered afterwards but typing this by hand is a pure pain in the ass.


Multiple Inheritance in C#

Is it a good concept to use multiple inheritance or can I do other things instead?

Why should I avoid multiple inheritance in C++?

I have a generic interface

    public interface Consumer&lt;E&gt; {
        public void consume(E e);
    }

I have a class that consumes two types of objects, so I would like to do something like:

    public class TwoTypesConsumer implements Consumer&lt;Tomato&gt;, Consumer&lt;Apple&gt;
    {
       public void consume(Tomato t) {  .....  }
       public void consume(Apple a) { ...... }
    }

Apparently I can&#39;t do that.

I can of course implement the dispatch myself, e.g.

    public class TwoTypesConsumer implements Consumer&lt;Object&gt; {
       public void consume(Object o) {
          if (o instanceof Tomato) { ..... }
          else if (o instanceof Apple) { ..... }
          else { throw new IllegalArgumentException(...) }
       }
    }

But I am looking for the compile-time type-checking and dispatching solution that generics provide.

The best solution I can think of is to define separate interfaces, e.g.

    public interface AppleConsumer {
       public void consume(Apple a);
    }

Functionally, this solution is OK, I think. It&#39;s just verbose and ugly.

Any ideas? 

How to make a Java class that implements one interface with two generic types?

In an attempt to fully understand how to solve Java&#39;s multiple inheritance problems I have a classic question that I need clarified.
 
Lets say I have class `Animal` this has sub classes `Bird` and `Horse` and I need to make a class `Pegasus` that extends from `Bird` and `Horse` since `Pegasus` is both a bird and a horse.
 
I think this is the classic diamond problem. From what I can understand the classic way to solve this is to make the `Animal`, `Bird` and `Horse` classes interfaces and implement `Pegasus` from them. 

I was wondering if there was another way to solve the problem in which I can still create objects for birds and horses. If there was a way to be able to create animals also that would be great but not necessary.


Java Multiple Inheritance

What is the difference between Mixins and Traits?

&lt;a href=&quot;http://en.wikipedia.org/wiki/Trait_(abstract_type)&quot;&gt;According to Wikipedia&lt;/a&gt;, Ruby Modules are sort of like traits. How so?

Mixins vs. Traits

Can an interface extend multiple interfaces in Java? This code appears valid in my IDE and it does compile:

    interface Foo extends Runnable, Set, Comparator&lt;String&gt; { }

but I had heard that multiple inheritance was not allowed in Java. Why does there appear to be an exception for interfaces?

Can an interface extend multiple interfaces in Java?

I&#39;ve come to a point where I need to have some sort of rudimentary multiple inheritance happening in JavaScript. (I&#39;m not here to discuss whether this is a good idea or not, so please kindly keep those comments to yourself.)

I just want to know if anyone&#39;s attempted this with any (or not) success, and how they went about it.

To boil it down, what I really need is to be able to have an object capable of inheriting a property from more than one prototype *chain* (i.e. each prototype could have its own proper chain), but in a given order of precedence (it will search the chains in order for the first definition).

To demonstrate how this is theoretically possible, it could be achieved by attaching the secondary chain onto the end of the primary chain, but this would affect all instances of any of those previous prototypes and that&#39;s not what I want.

Thoughts?

Multiple inheritance/prototypes in JavaScript

I can see people asking all the time whether multiple inheritance should be included into the next version of C# or Java. C++ folks, who are fortunate enough to have this ability, say that this is like giving someone a rope to eventually hang themselves. 

What’s the matter with multiple inheritance? Are there any concrete samples? 


What is the exact problem with multiple inheritance?

I know that multiple inheritance is not allowed in Java and C#. Many books just say, multiple inheritance is not allowed. But it can be implemented by using interfaces. Nothing is discussed about why it is not allowed. Can anybody tell me precisely why it is not allowed?

Why is Multiple Inheritance not allowed in Java or C#?

    class A                     { public: void eat(){ cout&lt;&lt;&quot;A&quot;;} }; 
    class B: virtual public A   { public: void eat(){ cout&lt;&lt;&quot;B&quot;;} }; 
    class C: virtual public A   { public: void eat(){ cout&lt;&lt;&quot;C&quot;;} }; 
    class D: public         B,C { public: void eat(){ cout&lt;&lt;&quot;D&quot;;} }; 
     
    int main(){ 
        A *a = new D(); 
        a-&gt;eat(); 
    } 

I understand the diamond problem, and above piece of code does not have that problem.

How exactly does virtual inheritance solve the problem?

**What I understand:**
When I say `A *a = new D();`, the compiler wants to know if an object of type `D` can be assigned to a pointer of type `A`, but it has two paths that it can follow, but cannot decide by itself.

So, how does virtual inheritance resolve the issue (help compiler take the decision)?

How does virtual inheritance solve the &quot;diamond&quot; (multiple inheritance) ambiguity?

How can an anonymous class implement two (or more) interfaces? Alternatively, how can it **both** extend a class **and** implement an interface?
For example, I want to create an object of anonymous class that extends two interfaces:

&lt;!-- language: java --&gt;

        // Java 10 &quot;var&quot; is used since I don&#39;t know how to specify its type
        var lazilyInitializedFileNameSupplier = (new Supplier&lt;String&gt; implements AutoCloseable)() {
            private String generatedFileName;
            @Override
            public String get() { // Generate file only once
                if (generatedFileName == null) {
                  generatedFileName = generateFile();
                }
                return generatedFileName;
            }
            @Override
            public void close() throws Exception { // Clean up
                if (generatedFileName != null) {
                  // Delete the file if it was generated
                  generatedFileName = null;
                }
            }
        };

Then I can use it in a try-with-resources block as `AutoCloseable` as lazily-initialized utility class:

&lt;!-- language: java --&gt;

            try (lazilyInitializedFileNameSupplier) {
                // Some complex logic that might or might not 
                // invoke the code that creates the file
                if (checkIfNeedToProcessFile()) {
                    doSomething(lazilyInitializedFileNameSupplier.get());
                }
                if (checkIfStillNeedFile()) {
                    doSomethingElse(lazilyInitializedFileNameSupplier.get());
                }
            } 
            // By now we are sure that even if the file was generated, it doesn&#39;t exist anymore

I don&#39;t want to create an inner class because I&#39;m absolutely sure that this class won&#39;t be used anywhere except the method I need to use it in (and I also *might* want to use local variables declared in that method that might be of `var` type).

Multiple inheritance for an anonymous class

If I have two interfaces , both quite different in their purposes , but with same method signature , how do I make a class implement both without being forced to write a single method that serves for the both the interfaces and writing some convoluted logic in the method implementation that checks for which type of object the call is being made and invoke proper code ?

In C# , this is overcome by what is called as explicit interface implementation. Is there any equivalent way in Java ?
 

Java - Method name collision in interface implementation

I have 2 classes one includes methodA and the other include methodB. So in a new class I need to override the methods methodA and methodB. So how do I achieve multiple inheritance in objective C? I am little bit confused with the syntax.

Objective-C multiple inheritance

A new feature coming in JDK 8 allows you to add to an existing interface while preserving binary compatibility.

The syntax is like

    public interface SomeInterface() {
      void existingInterface();
      void newInterface() default SomeClass.defaultImplementation;
    }

This way for all existing implementations of `SomeInterface` when they upgrade to this new version they don&#39;t all suddenly have compiles errors around `newInterface()`.

While this is neat, what happens when you are implementing two interfaces which both have added a new defaulted method which you did not implement?  Let me explain with an example.

    public interface Attendance {
       boolean present() default DefaultAttendance.present;
    }

    public interface Timeline {
       boolean present() default DefaultTimeline.present;
    }

    public class TimeTravelingStudent implements Attendance, Timeline {

    }

    // which code gets called?
    new TimeTravelingStudent().present();

Has this been defined as part of JDK 8 yet?

I found the Java gods talking about something similar here http://cs.oswego.edu/pipermail/lambda-lib/2011-February/000068.html, but its part of private mailing list and I cannot ask them directly.


See this for more details on how defaults are going to be used in JDK 8 and extending the Collection interface to support lambdas:
https://oracleus.wingateweb.com/published/oracleus2011/sessions/25066/25066_Cho223662.pdf

Are defaults in JDK 8 a form of multiple inheritance in Java?

Consider the following snippet of python code

    class A(object):
        def __init__(self, a):
            self.a = a

    class B(A):
        def __init__(self, a, b):
            super(B, self).__init__(a)
            self.b = b

    class C(A):
        def __init__(self, a, c):
            super(C, self).__init__(a)
            self.c = c

    class D(B, C):
        def __init__(self, a, b, c, d):
            #super(D,self).__init__(a, b, c) ???
            self.d = d

I am wondering how can I pass `a`, `b` and `c` to corresponding base classes&#39; constructors.

python multiple inheritance passing arguments to constructors using super

My class should extend two classes at the same time:

    public class Preferences extends AbstractBillingActivity {
    
    public class Preferences extends PreferenceActivity {

How to do so?


**Upd**. Since this is not possible, how should I use that [AbstractBillingActivity][1] with Preferences then?

**Upd2**. If I go with interfaces, should I create:

 1. BillingInterface
    
        public interface BillingInterface extends PreferenceActivity, AbstractBillingActivity {
        
        }
    
 2. PreferenceActivity
    
        public interface PreferenceActivity {
        
        }
    
 3. AbstractBillingActivity
    
        public interface AbstractBillingActivity {
            
            	void onCreate(Bundle savedInstanceState);
            
        }

and then 

    public class Preferences implements BillingInterface {

  [1]: http://github.com/robotmedia/AndroidBillingLibrary






Can one class extend two classes?

I still have some confusion about this thing. What I have found till now is 

(Similar questions have already been asked here but I was having some other points.)

&gt; 1. Interface is collection of ONLY abstract methods and final fields.
&gt;
&gt; 2. There is no multiple inheritance in Java.
&gt;
&gt; 3. Interfaces can be used to achieve multiple inheritance in Java.
&gt;
&gt; 4. One Strong point of Inheritance is that We can use the code of base class in derived class without writing it again. May be this is the most important thing for inheritance to be there.

Now..

&gt; Q1. As interfaces are having only abstract methods (no code) so how can we say that if we are implementing any interface then it is inheritance ? We are not using its code.
&gt;
&gt; Q2. If implementing an interface is not inheritance then How interfaces are used to achieve multiple inheritance ?
&gt;
&gt; Q3. Anyhow what is the benefit of using Interfaces ? They are not having any code. We need to write code again and again in all classes we implement it. 

**Then why to make interfaces ?**

**NOTE :** I have found one case in which interfaces are helpful. One example of it is like in Runnable interface we have public void run() method in which we define functionality of thread and there is built in coding that this method will be run as a separate thread. So we just need to code what to do in thread, Rest is pre-defined. But this thing also can be achieved using abstract classes and all. 

**Then what are the exact benefits of using interfaces? Is it really Multiple-Inheritance that we achieve using Interfaces?**

Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?

I am reading &quot;The Java Tutorial&quot; (for the 2nd time). I just got through the section on Interfaces (again), but still do not understand how Java Interfaces simulate multiple inheritance. Is there a clearer explanation than what is in the book? 

How do Java Interfaces simulate multiple inheritance?

If we have a class that inherits from multiple interfaces, and the interfaces have methods with the same name, how can we implement these methods in my class? How can we specify which method of which interface is implemented?


Inheritance from multiple interfaces with the same method name

Recently I came across a class that uses `use` statement inside of the class definition.

Could someone explain what exactly does it do - as I can&#39;t find any information about it.

I understand that it might be a way of moving it away form a global scope of the given file, but does it perhaps allow the given class inherit from multiple parent classes as well - since `extends` only allows one parent class reference?

The example I saw was in the User model of the original installation of Laravel:

    &lt;?php
    
    use Illuminate\Auth\UserTrait;
    use Illuminate\Auth\UserInterface;
    use Illuminate\Auth\Reminders\RemindableTrait;
    use Illuminate\Auth\Reminders\RemindableInterface;
    
    class User extends Eloquent implements UserInterface, RemindableInterface {
    
    	use UserTrait, RemindableTrait;
    
    	/**
    	 * The database table used by the model.
    	 *
    	 * @var string
    	 */
    	protected $table = &#39;users&#39;;
    
    	/**
    	 * The attributes excluded from the model&#39;s JSON form.
    	 *
    	 * @var array
    	 */
    	protected $hidden = array(&#39;password&#39;, &#39;remember_token&#39;);
    
    }

and I&#39;ve seen some examples of this model actually using methods included within the `UserTrait` class - hence my suspicion, but would really like to find out more about the meaning of the enclosed `use` statements.

[PHP documentation][1] says:

&gt; The use keyword must be declared in the outermost scope of a file (the
&gt; global scope) or inside namespace declarations. This is because the
&gt; importing is done at compile time and not runtime, so it cannot be
&gt; block scoped. The following example will show an illegal use of the
&gt; use keyword:

followed by the example:

    namespace Languages;
    
    class Greenlandic
    {
        use Languages\Danish;
    
        ...
    }

which would indicate that it is an incorrect use of the `use` keyword - any clues?


  [1]: http://php.net/manual/en/language.namespaces.importing.php

PHP : &#39;use&#39; inside of the class definition

A short example outputs a weird result!

    #include &lt;iostream&gt;
    
    using namespace std;
    
    struct A { int a; };    
    struct B { int b; };
    struct C : A, B
    {
    	int c;
    };
    
    int main()
    {
    	C* c = new C;
    	B* b = c;
    
    	cout &lt;&lt; &quot;The address of b is 0x&quot; &lt;&lt; hex &lt;&lt; b &lt;&lt; endl;
    	cout &lt;&lt; &quot;The address of c is 0x&quot; &lt;&lt; hex &lt;&lt; c &lt;&lt; endl;
    
    	if (b == c)
    	{
    		cout &lt;&lt; &quot;b is equal to c&quot; &lt;&lt; endl;
    	}
    	else
    	{
    		cout &lt;&lt; &quot;b is not equal to c&quot; &lt;&lt; endl;
    	}
    }

**It&#39;s very surprising to me that the output should be as follows:**

    The address of b is 0x003E9A9C
    The address of c is 0x003E9A98
    b is equal to c

What makes me wonder is:

**0x003E9A9C is not equal to 0x003E9A98, but the output is &quot;b is equal to c&quot;**

Pointer values are different but they compare equal. Why?

I know that multiple inheritances between Interfaces is possible, e.g.:

    public interface C extends A,B {...} //Where A, B and C are Interfaces

But is it possible to have a regular Class inherit from multiple Interfaces like this:

    public class A implements C,D {...} //Where A is a Class and C and D are interfaces



Can a normal Class implement multiple interfaces?

I&#39;d like to use a Mixin to always add some init functionality to my child classes which each inherit from different API base classes. Specifically, I&#39;d like to make multiple different child classes that inherit from one of these different API-supplied base classes and the one Mixin, which will always have the Mixin initialization code executed in the same way, without code replication.  However, it seems that the \_\_init\_\_ function of the Mixin class never gets called unless I explicitly call it in the Child class&#39;s \_\_init\_\_ function, which is less than ideal.  I&#39;ve built up a simple test case:

    class APIBaseClassOne(object):
        def __init__(self, *args, **kwargs):
            print (&quot; base &quot;)
     
    class SomeMixin(object):
        def __init__(self, *args, **kwargs):
            print (&quot; mixin before &quot;)
            super(SomeMixin, self).__init__(*args, **kwargs)
            print (&quot; mixin after &quot;)
     
    class MyClass(APIBaseClassOne):
        pass
     
    class MixedClass(MyClass, SomeMixin):
        pass

As you can see in the following output, the Mixin function&#39;s init never gets called:
     
    &gt;&gt;&gt; import test
    &gt;&gt;&gt; test.MixedClass()
     base
    &lt;test.MixedClass object at 0x1004cc850&gt;

Is there a way to do this (have an init function in a Mixin get called) without writing every child class to explicitly invoke the Mixin&#39;s init function? (i.e., without having to do something like this in every class:)

    class MixedClass(MyClass, SomeMixin):
        def __init__(*args, **kwargs):
            SomeMixin.__init__(self, *args, **kwargs)
            MyClass.__init__(self, *args, **kwargs) 

Btw, if all my child classes were inheriting from same base class, I realize I could create a new middle class that inherits from the base class and the mixin and keep it DRY that way. However, they inherit from different base classes with common functionality. (Django Field classes, to be precise).



Are Mixin class __init__ functions not automatically called?

http://en.wikipedia.org/wiki/Diamond_problem

I know what it means, but what steps can I take to avoid it?

How can I avoid the Diamond of Death when using multiple inheritance?

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(&#39;Init {} with arguments {}&#39;.format(self.__class__.__name__, (a, b)))
    
    class B(object):
    	def __init__(self, q):
    		super(B, self).__init__()
    		print(&#39;Init {} with arguments {}&#39;.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 the error:

    Traceback (most recent call last):
      File &quot;test.py&quot;, line 16, in &lt;module&gt;
        c = C()
      File &quot;test.py&quot;, line 13, in __init__
        super(A, self).__init__(1, 2)
    TypeError: __init__() takes 2 positional arguments but 3 were given


I found [this resource][1] which explains mutiple inheritance with different set of arguments, but they suggest to use `*args` and `**kwargs` to use for all argument. I consider this very ugly, since I cannot see from the constructor call in the child class what kind of parameters I pass to the parent classes. 


  [1]: https://www.packtpub.com/books/content/inheritance-python

Multiple inheritance in python3 with different signatures

There are two base classes have same function name.  I want to inherit both of them, and  over ride each method differently.  How can I do that with separate declaration and definition (instead of defining in the class definition)?

    #include &lt;cstdio&gt;
    
    class Interface1{
    public:
        virtual void Name() = 0;
    };
    
    class Interface2
    {
    public:
        virtual void Name() = 0;
    };
    
    class RealClass: public Interface1, public Interface2
    {
    public:
        virtual void Interface1::Name()
        {
            printf(&quot;Interface1 OK?\n&quot;);
        }
        virtual void Interface2::Name()
        {
            printf(&quot;Interface2 OK?\n&quot;);
        }
    };
    
    int main()
    {
        Interface1 *p = new RealClass();
        p-&gt;Name();
        Interface2 *q = reinterpret_cast&lt;RealClass*&gt;(p);
        q-&gt;Name();
    }   

I failed to move the definition out in VC8.  I found the Microsoft Specific Keyword __interface can do this job successfully, code below:

    #include &lt;cstdio&gt;
    
    __interface Interface1{
        virtual void Name() = 0;
    };
    
    __interface Interface2
    {
        virtual void Name() = 0;
    };
    
    class RealClass: public Interface1,
                    public Interface2
    {
    public:
        virtual void Interface1::Name();
        virtual void Interface2::Name();
    };
    
    void RealClass::Interface1::Name()
    {
        printf(&quot;Interface1 OK?\n&quot;);
    }
    
    void RealClass::Interface2::Name()
    {
        printf(&quot;Interface2 OK?\n&quot;);
    }
    
    int main()
    {
        Interface1 *p = new RealClass();
        p-&gt;Name();
        Interface2 *q = reinterpret_cast&lt;RealClass*&gt;(p);
        q-&gt;Name();
    }  

but is there another way to do this something more general that will work in other compilers?

Inherit interfaces which share a method name

I need to create a class that uses a different base class depending on some condition. With some classes I get the infamous:

    TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

One example is `sqlite3`, here is a short example you can even use in the interpreter:

&lt;!-- language: lang-none --&gt;

    &gt;&gt;&gt; import sqlite3
    &gt;&gt;&gt; x = type(&#39;x&#39;, (sqlite3,), {})
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases


Resolving metaclass conflicts

A colleague and I are having a bit of an argument over multiple inheritance.  I&#39;m saying it&#39;s not supported and he&#39;s saying it is.  So, I thought that I&#39;d ask the brainy bunch on the net.

Does C# support multiple inheritance?

&lt;!-- language: cxx --&gt;

    template &lt;typename CRTP&gt;
    struct Pre {
        CRTP &amp; operator++();
    };

    template &lt;typename CRTP&gt;
    struct Post {
        CRTP operator++(int);
    };

    struct Derived
        : Pre&lt;Derived&gt;
        , Post&lt;Derived&gt;
    {};

    int main() {
        Derived d;
        d++;
        ++d;
    }
    
I get these errors from GCC:

&lt;!-- language: none --&gt;

    &lt;source&gt;: In function &#39;int main()&#39;:
    &lt;source&gt;:18:10: error: request for member &#39;operator++&#39; is ambiguous
            d++;
            ^~
    &lt;source&gt;:8:14: note: candidates are: CRTP Post&lt;CRTP&gt;::operator++(int) [with CRTP = Derived]
            CRTP operator++(int);
                ^~~~~~~~
    &lt;source&gt;:3:16: note:                 CRTP&amp; Pre&lt;CRTP&gt;::operator++() [with CRTP = Derived]
            CRTP &amp; operator++();
                    ^~~~~~~~
    &lt;source&gt;:19:11: error: request for member &#39;operator++&#39; is ambiguous
            ++d;
            ^
    &lt;source&gt;:8:14: note: candidates are: CRTP Post&lt;CRTP&gt;::operator++(int) [with CRTP = Derived]
            CRTP operator++(int);
                ^~~~~~~~
    &lt;source&gt;:3:16: note:                 CRTP&amp; Pre&lt;CRTP&gt;::operator++() [with CRTP = Derived]
            CRTP &amp; operator++();
                    ^~~~~~~~

Pre-decrement and post-decrement operators cause similar errors. No such errors with Clang. Any ideas what could be wrong or how to work around this?

GCC can&#39;t differentiate between operator++() and operator++(int)

I&#39;m running Python 2.5, so this question may not apply to Python 3. When you make a diamond class hierarchy using multiple inheritance and create an object of the derived-most class, Python does the Right Thing (TM). It calls the constructor for the derived-most class, then its parent classes as listed from left to right, then the grandparent. I&#39;m familiar with Python&#39;s [MRO][1]; that&#39;s not my question. I&#39;m curious how the object returned from super actually manages to communicate to calls of super in the parent classes the correct order. Consider this example code:

    #!/usr/bin/python
    
    class A(object):
    	def __init__(self): print &quot;A init&quot;
    
    class B(A):
    	def __init__(self):
    		print &quot;B init&quot;
    		super(B, self).__init__()
    
    class C(A):
    	def __init__(self):
    		print &quot;C init&quot;
    		super(C, self).__init__()
    
    class D(B, C):
    	def __init__(self):
    		print &quot;D init&quot;
    		super(D, self).__init__()
    
    x = D()

The code does the intuitive thing, it prints:

    D init
    B init
    C init
    A init

However, if you comment out the call to super in B&#39;s init function, neither A nor C&#39;s init function is called. This means B&#39;s call to super is somehow aware of C&#39;s existence in the overall class hierarchy. I know that super returns a proxy object with an overloaded get operator, but how does the object returned by super in D&#39;s init definition communicate the existence of C to the object returned by super in B&#39;s init definition? Is the information that subsequent calls of super use stored on the object itself? If so, why isn&#39;t super instead self.super?

Edit: Jekke quite rightly pointed out that it&#39;s not self.super because super is an attribute of the class, not an instance of the class. Conceptually this makes sense, but in practice super isn&#39;t an attribute of the class either! You can test this in the interpreter by making two classes A and B, where B inherits from A, and calling `dir(B)`. It has no `super` or `__super__` attributes.

  [1]: http://www.python.org/download/releases/2.3/mro/


How does Python&#39;s &quot;super&quot; do the right thing?

First of all... Sorry for this post. I know that there are many many posts on stackoverflow which are discussing multiple inheritance. But I already know that Java does not support multiple inheritance and I know that using interfaces should be an alternative. But I don&#39;t get it and see my dilemma:

I have to make changes on a very very large and complex tool written in Java. In this tool there is a data structure built with many different class objects with a linked member hierarchy. Anyway...

 - I have one class `Tagged` which has multiple methods and returns an object tag depending on the object&#39;s class. It needs members and static variables.
 - And a second class called `XMLElement` allows to link objects and in the end generate a XML file. I also need member and static variables here.
 - Finally, I have these many many data classes which nearly all should extend `XMLElement` and some of them `Tagged`.

Ok ok, this won&#39;t work since it&#39;s only possible to extend just one class. I read very often that everything with Java is ok and there is no need for having multiple inheritance. I believe, but I don&#39;t see how an interface should replace inheritance. 

 1. It makes no sense to put the real implementation in all data classes since it is the same every time but this would be necessary with interfaces (I think). 
 2.  I don&#39;t see how I could change one of my inheritance classes to an interface. I have variables in here and they have to be exactly there.

I really don&#39;t get it so please can somebody explain me how to handle this?

How can interfaces replace the need for multiple inheritance when have existing classes

I have come across numerous arguments against the inclusion of multiple inheritance in C#, some of which include (philosophical arguments aside):

  - Multiple inheritance is too complicated and often ambiguous
  - It is unnecessary because interfaces provide something similar
  - Composition is a good substitute where interfaces are inappropriate

I come from a C++ background and miss the power and elegance of multiple inheritance. Although it is not suited to all software designs there are situations where it is difficult to deny it&#39;s utility over interfaces, composition and similar OO techniques.

Is the exclusion of multiple inheritance saying that developers are not smart enough to use them wisely and are incapable of addressing the complexities when they arise?

I personally would welcome the introduction of multiple inheritance into C# (perhaps C##).


----------
**Addendum**: I would be interested to know from the responses who comes from a single (or procedural background) versus a multiple inheritance background. I have often found that developers who have no experience with multiple inheritance will often default to the multiple-inheritance-is-unnecessary argument simply because they do not have any experience with the paradigm.

Should C# have multiple inheritance?

In Python, how do I pick which Parent&#39;s method to call? Say I want to call the parent ASDF2&#39;s `__init__` method. Seems like I have to specify __ASDF1__ in the super()..? And if I want to call ASDF3&#39;s `__init__`, then I must specify __ASDF2__?!

    &gt;&gt;&gt; class ASDF(ASDF1, ASDF2, ASDF3):
    	def __init__(self):
    		super(ASDF1, self).__init__()
    
    		
    &gt;&gt;&gt; ASDF()
    ASDF2&#39;s __init__ happened
    &gt;&gt;&gt; class ASDF(ASDF1, ASDF2, ASDF3):
    	def __init__(self):
    		super(ASDF2, self).__init__()
    
    		
    &gt;&gt;&gt; ASDF()
    ASDF3&#39;s __init__ happened

Seems bonkers to me. What am I doing wrong?

Python&#39;s Multiple Inheritance: Picking which super() to call

It&#39;s legal to do this in Java:

     void spew(Appendable x)
     {
         x.append(&quot;Bleah!\n&quot;);
     }

How can I do this (syntax not legal):

     void spew(Appendable &amp; Closeable x)
     {
         x.append(&quot;Bleah!\n&quot;);
         if (timeToClose())
             x.close();
     }

**I would like if possible to force callers to use objects that are both Appendable and Closeable, without requiring a specific type.** There are multiple standard classes that do this, e.g. BufferedWriter, PrintStream, etc.

If I define my own interface

     interface AppendableAndCloseable extends Appendable, Closeable {}

that won&#39;t work since the standard classes that implement Appendable and Closeable do not implement my interface AppendableAndCloseable (unless I don&#39;t understand Java as well as I think I do... empty interfaces still add uniqueness above and beyond their superinterfaces).

The closest I can think of is to do one of the following:

 1. pick one interface (e.g. Appendable), and use runtime tests to ensure the argument is an `instanceof` the others. Downside: problem not caught at compile time.

 2. require multiple arguments (catches compile-time correctness but looks dorky):

        void spew(Appendable xAppend, Closeable xClose)
        {
            xAppend.append(&quot;Bleah!\n&quot;);
            if (timeToClose())
                xClose.close();
        }



How can I require a method argument in Java to implement multiple interfaces?

The following snippet produces an &quot;ambigious call to foo&quot; error during compilation, and I&#39;d like to know if there is any way around this problem without fully qualifying the call to foo:

    #include &lt;iostream&gt;
    
    struct Base1{
    	void foo(int){
    	}
    };
    
    struct Base2{
    	void foo(float){
    	}
    };
    
    struct Derived : public Base1, public Base2{
    };
    
    int main(){
    	Derived d;
    	d.foo(5);
    
    	std::cin.get();
    	return 0;
    }
So, question is as the title says. Ideas? I mean, the following works flawlessly:

    #include &lt;iostream&gt;

    struct Base{
    	void foo(int){
    	}
    };

    struct Derived : public Base{
    	void foo(float){
    	}
    };
    
    int main(){
    	Derived d;
    	d.foo(5);
    
    	std::cin.get();
    	return 0;
    }

All Multiple Inheritance Solutions on Gang of Coders

Total of 39 Multiple Inheritance Solutions