Wie deklariert man eine Schnittstelle in C++?

Question

Wie kann ich eine Klasse einrichten, die eine Schnittstelle darstellt? Ist dies nur eine abstrakte Basisklasse?

Answer 1

Zur Erweiterung der Antwort von bradtgmurray können Sie eine Ausnahme von der rein virtuellen Methodenliste Ihrer Schnittstelle machen, indem Sie einen virtuellen Destruktor hinzufügen. Damit können Sie den Besitz eines Zeigers an eine andere Partei weitergeben, ohne die konkrete abgeleitete Klasse offenzulegen. Der Destruktor muss nichts tun, da die Schnittstelle keine konkreten Mitglieder hat. Es mag widersprüchlich erscheinen, eine Funktion sowohl als virtuell als auch als Inline zu definieren, aber glauben Sie mir - das ist es nicht.

class IDemo
{
    public:
        virtual ~IDemo() {}
        virtual void OverrideMe() = 0;
};

class Parent
{
    public:
        virtual ~Parent();
};

class Child : public Parent, public IDemo
{
    public:
        virtual void OverrideMe()
        {
            //do stuff
        }
};

Sie müssen keinen Body für den virtuellen Destruktor einfügen - es hat sich herausgestellt, dass einige Compiler Probleme haben, einen leeren Destruktor zu optimieren, und Sie sind besser dran, wenn Sie den Standard verwenden.

Answer 2

Erstellen Sie eine Klasse mit rein virtuellen Methoden. Verwenden Sie die Schnittstelle, indem Sie eine andere Klasse erstellen, die diese virtuellen Methoden außer Kraft setzt.

Eine rein virtuelle Methode ist eine Klassenmethode, die als virtuell definiert und 0 zugewiesen ist.

class IDemo
{
    public:
        virtual ~IDemo() {}
        virtual void OverrideMe() = 0;
};

class Child : public IDemo
{
    public:
        virtual void OverrideMe()
        {
            // do stuff
        }
};

Answer 3

Der ganze Grund, warum es in C#/ zusätzlich zu den abstrakten Basisklassen eine spezielle Interface-Typ-Kategorie gibt Java ist, weil C#/Java keine Mehrfachvererbung unterstützen.

C++ unterstützt Mehrfachvererbung, so dass ein spezieller Typ nicht erforderlich ist. Eine abstrakte Basisklasse ohne nicht-abstrakte (rein virtuelle) Methoden ist funktional äquivalent zu einer C#/Java-Schnittstelle.

Answer 4

In C++ gibt es kein Konzept der "Schnittstelle" per se. AFAIK wurden Schnittstellen zuerst in Java eingeführt, um das Fehlen der Mehrfachvererbung zu umgehen. Dieses Konzept hat sich als sehr nützlich erwiesen, und der gleiche Effekt kann in C++ durch die Verwendung einer abstrakten Basisklasse erzielt werden.

Eine abstrakte Basisklasse ist eine Klasse, in der mindestens eine Mitgliedsfunktion (Methode im Java-Jargon) eine rein virtuelle Funktion ist, die mit der folgenden Syntax deklariert wird:

class A
{
  virtual void foo() = 0;
};

Eine abstrakte Basisklasse kann nicht instanziiert werden, d. h. Sie können kein Objekt der Klasse A deklarieren. Sie können nur Klassen von A ableiten, aber jede abgeleitete Klasse, die keine Implementierung von foo() wird auch abstrakt sein. Um nicht mehr abstrakt zu sein, muss eine abgeleitete Klasse Implementierungen für alle reinen virtuellen Funktionen bereitstellen, die sie erbt.

Beachten Sie, dass eine abstrakte Basisklasse mehr sein kann als eine Schnittstelle, da sie Datenmitglieder und Mitgliedsfunktionen enthalten kann, die nicht rein virtuell sind. Ein Äquivalent zu einer Schnittstelle wäre eine abstrakte Basisklasse ohne Daten mit nur rein virtuellen Funktionen.

Und wie Mark Ransom betonte, sollte eine abstrakte Basisklasse einen virtuellen Destruktor bereitstellen, wie jede andere Basisklasse übrigens auch.

Answer 5

Soweit ich testen konnte, ist es sehr wichtig, den virtuellen Destruktor hinzuzufügen. Ich verwende Objekte, die mit new und zerstört mit delete .

Wenn Sie den virtuellen Destruktor nicht in die Schnittstelle aufnehmen, wird der Destruktor der geerbten Klasse nicht aufgerufen.

class IBase {
public:
    virtual ~IBase() {}; // destructor, use it to call destructor of the inherit classes
    virtual void Describe() = 0; // pure virtual method
};

class Tester : public IBase {
public:
    Tester(std::string name);
    virtual ~Tester();
    virtual void Describe();
private:
    std::string privatename;
};

Tester::Tester(std::string name) {
    std::cout << "Tester constructor" << std::endl;
    this->privatename = name;
}

Tester::~Tester() {
    std::cout << "Tester destructor" << std::endl;
}

void Tester::Describe() {
    std::cout << "I'm Tester [" << this->privatename << "]" << std::endl;
}

void descriptor(IBase * obj) {
    obj->Describe();
}

int main(int argc, char** argv) {

    std::cout << std::endl << "Tester Testing..." << std::endl;
    Tester * obj1 = new Tester("Declared with Tester");
    descriptor(obj1);
    delete obj1;

    std::cout << std::endl << "IBase Testing..." << std::endl;
    IBase * obj2 = new Tester("Declared with IBase");
    descriptor(obj2);
    delete obj2;

    // this is a bad usage of the object since it is created with "new" but there are no "delete"
    std::cout << std::endl << "Tester not defined..." << std::endl;
    descriptor(new Tester("Not defined"));

    return 0;
}

Wenn Sie den vorherigen Code ohne virtual ~IBase() {}; werden Sie sehen, dass der Destruktor Tester::~Tester() wird nie aufgerufen.