C++: mit einer Basis-Klasse als Implementierung einer Schnittstelle

Wenn Base ist nicht abgeleitet von Interface, dann müssen Sie haben die Weiterleitung von Gesprächen in Derived. Es ist nur - "overhead" in dem Sinne, dass müssen Sie zusätzlichen code schreiben. Ich vermute, dass der optimizer damit es so effizient, als wenn Sie Ihre ursprüngliche Idee gearbeitet hatte.

class Interface {
    public:
        virtual void myfunction() = 0;
};

class Base {
    public:
        virtual void myfunction() {/*...*/}
};

class Derived : public Interface, public Base {
    public:
        void myfunction() { Base::myfunction(); }  //forwarding call
};

int main() {
   Derived d;
   d.myfunction();
   return 0;
}

Nicht. (nicht, dass sowieso Weg)

Könnten Sie in die Irre führen lassen durch die Art und Weise, die Dinge tun, die in anderen Sprachen wie Java, C#, ActionScript, etc.

In C++, multiple Vererbung und die Art und Weise virtuelle Klassen verwaltet werden, macht Schnittstellen (wie in anderen Sprachen) obsolet. In diesen anderen Sprachen, Schnittstellen werden verwendet, um die Probleme beheben, die aus der fehlenden Mehrfachvererbung (gut oder schlecht, es ist eine Wahl).

Also, wenn das, was Sie tun möchten ist, geben Sie einfach eine Allgemeine Schnittstelle mit einige virtuelle Methoden, die Bereitstellung von Standard-Implementierungen, nur die Implementierung in der Basisklasse :

class Interface
{
    virtual void myfunction() { /*...*/ } ; //default implementation
    virtual void yourFunction()  = 0 ; //this one HAVE TO be implemented by the user
}
class Derived
    : public public Interface //dont' need another clas
{
    //myfunction is implemented by base
    void yourFunction(); //have to implement yourFunction
}
class DerivedB
    : public public Interface //dont' need another clas
{
    void myFunction();//myfunction is implemented by base but we implement it for this specific class
    void yourFunction(); //have to implement yourFunction
}

Wenn Sie jedoch möchten, um mehrere Basisklassen, die die gleichen Schnittstellen haben, dann denken Sie, dass Ihre interface-Klasse wird die Grundlagen der anderen Klassen

//in this order
class Interface
{
    virtual void myfunction() = 0;
}
class BaseA : public Interface
{   
    //here "virtual" is optional as if the parent is virtual, the child is virtual too
    virtual void myfunction() {/*...*/}; //BaseA specific implementation
}
class BaseB : public Interface
{
    virtual void myfunction() {/*...*/}; //BaseB specific implementation
}

Es ist jedoch ein nicht-wirklich-einfach-zu-Lesen - (read: nicht empfohlen) Weg, um eine default-Implementierung, SONDERN zwingt den Benutzer explizit sagen, ob er es nutzen will oder nicht. Sie nutzen die Tatsache, dass auch Reine virtuelle Funktionen können default-Implementierungen aufgerufen werden kann :

class Interface
{
    virtual void myfunction() { /*...*/ } ; //default implementation
    virtual void yourFunction()  = 0 ; //this one HAVE TO be implemented by the user BUT provide a default implementation!
}

//in Interface.cpp 

void Interface::yourFunction() //default implementation of the virtual pure function
{ /*...*/ }

//in Derived.h

class DerivedA
    : public public Interface //dont' need another clas
{
    //myfunction is implemented by base
    void yourFunction(); //have to implement yourFunction -- DerivedA specific
}

class DerivedB
    : public public Interface //dont' need another clas
{
    void myFunction();//myfunction is implemented by base but we implement it for this specific class
    void yourFunction() { Interface::yourFunction(); } //uses default implementation of yourFunction, hidden but existing
}

Aber tun Sie es nicht.

Die Antwort ist unter der Annahme, dass die abgeleitete Klasse sein will CONCRETE Klasse oder eine nicht abstrakte Klasse, ich.e es gewünscht ist, in der Lage sein, um Objekte zu instanziieren der Typ 'Derived'.. Auch ich nehme an öffentliche member-Funktionen in meiner Antwort.

Nicht. Die abgeleitete Klasse implementieren muss alle rein virtuellen Funktionen, die es erbt von allen Basisklassen. In diesem Fall 'Base::myfunction' obwohl vererbt 'Derived' wird nicht behandelt, wie eine Implementierung von 'Derived::myfunction'

'Derived::myfunction' noch eine Implementierung von 'Interface::myfunction'.

Eine Möglichkeit kann sein, dass 'Derived::myfunction' können intern delegieren zu 'Base::myfunction'

Aber wenn es nicht gewünscht Derived zu einer konkreten Klasse (was ich bezweifle, ist die Absicht des OP), dann ist die obige Anordnung der Klassen ist in Ordnung (der Sprache, Perspektive)