C++ Wie multipliziert man Vererbungen von Interfaces mit unterschiedlichen Rückgabetypen?

Question

Vielleicht ich habe zwei Schnittstellen mit dem gleichen Funktionsnamen und Parameter, jedoch mit unterschiedlichen Rückgabewerte:

struct A { virtual void foo() = 0; }; 
struct B { virtual int foo() = 0; }; 

Wie Klasse C zu definieren, das erbt diese Schnittstellen (wenn es natürlich möglich ist)? Zum Beispiel schreibe ich einige Pseudo-Code, der nicht kompiliert hat:

// this code is fake, it doesn't compiled!! 
struct C : A, B 
{ 
    // how to tell compiler what method using if referenced from C? 
    using void foo(); // incorrect in VS 2012 
    // and override A::foo() and B::foo()? 
    virtual void foo() { std::cout << "void C::foo();\n"; } // incorrect 
    virtual int foo() { std::cout << "int C::foo();\n"; return 0; } // incorrect 
} 
// ... for use in code 
C c; 
A &a = c; 
B &b = c; 
c.foo();  // call void C::foo() when reference from C instance 
a.foo();  // call void C::foo() when reference from A instance 
b.foo();  // call int C::foo() when reference from B instance 

Answer 1

es nicht möglich ist, aber nicht wegen der Mehrfachvererbung. Mehrdeutigkeit tritt aufgrund ungültiger Überlast von foo in Klasse C auf. Sie können nicht int foo() und void foo() haben, da der Rückgabetyp nicht Teil der Funktionssignatur ist. Daher kann der Compiler die Aufrufe von foo nicht auflösen. Sie können Ihre Schnittstelle als eine Vereinigung der Klassen A und B betrachten, so dass das Problem logischerweise bereits vor der eigentlichen Vererbung vorliegt. Da aus der Compilerperspektive A und B zwei unterschiedliche und nicht verwandte Typen sind, gibt es kein Problem beim Kompilieren, und der Fehler wird bis zum Punkt der tatsächlichen Vereinigung in Klasse C verzögert.

mehr Siehe hier über Funktionssignaturen und Überlastung: Is the return type part of the function signature?

Answer 2

Es ist nicht möglich, eine virtuelle Funktion des Rückgabetyp mit der gleichen Signatur zu überschreiben (wie @ icepack Antwort erklärt). Ein alternativer Ansatz könnte eine Vorlagenbasisklasse haben, die foo() mit einem als Vorlagenparameter angegebenen Rückgabetyp deklariert und Spezialisierungen für konkrete Rückgabeparametertypen bereitstellt.

Dies wäre eine Verallgemeinerung des Vorschlags von @Dietmar Kühl.

Answer 3

Was Sie können tun ist, alle das gemeinsame Material in eine virtual Basis zu stellen, sagen C_base und überschreiben die widersprüchlichen virtual Funktionen in Hilfsklassen, die jeweils. Da das gemeinsame Zeug für C ist leicht zugänglich in ist im Wesentlichen wie in einem am meisten abgeleiteten C. Schließlich Sie C Klasse, nur weil die Klasse Dinge Strang ziehen:

struct A { virtual void foo() = 0; }; 
struct B { virtual int foo() = 0; }; 

struct C_base { int all_data; }; 

struct A_aux: virtual C_base, A { 
    void foo() { std::cout << "A_aux::foo()\n"; } 
}; 

struct B_aux: virtual C_base, B { 
    int foo() { std::cout << "B_aux::foo()\n"; return 0; } 
}; 

struct C : A_aux, B_aux 
{ 
    using A_aux::foo; 
}; 

Answer 4

Sie explizit qualifizieren können.

class C : A, B { 
public: 
    void A::foo() { ... } 
    int B::foo() { ... } 
}; 

Edit:

Dies scheint ein MSVC Erweiterung, anstatt Standards.