WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Rein virtuelle Funktion (= 0) in C++

Mit `= 0` deklarierst du eine rein virtuelle Memberfunktion. So kannst du eine abstrakte Schnittstelle definieren, die je nach Objekttyp unterschiedliche Implementierungen aufruft.

Version: ISO C++23; implementation support may vary

Syntax

struct Strategy {
    virtual int apply(int x) const = 0;
    virtual ~Strategy() = default;
};

In virtual int apply(int x) const = 0; kennzeichnet = 0 eine rein virtuelle Memberfunktion. Es handelt sich weder um eine Zuweisung noch um einen Rückgabewert. Auch eine überschreibende Funktion kann rein virtuell sein: int apply(int x) const override = 0;.

Eine Klasse ist abstrakt, wenn für mindestens eine virtuelle Funktion die in dieser Klasse letztlich maßgebliche Version rein virtuell bleibt. Du kannst kein eigenständiges Objekt einer abstrakten Klasse erzeugen, aber ein Zeiger oder eine Referenz des Basistyps kann sich auf ein konkretes abgeleitetes Objekt beziehen. override deckt Fehler auf: Ohne const überschreibt Half::apply die Funktion Strategy::apply nicht.

Eine rein virtuelle Funktion kann außerhalb der Klasse definiert werden und bleibt trotzdem rein virtuell. Ein qualifizierter Aufruf wie strategy.Strategy::apply(12) umgeht den virtuellen Aufrufmechanismus und benötigt diese Definition. Ruft der Konstruktor oder Destruktor einer abstrakten Klasse direkt oder indirekt eine rein virtuelle Funktion virtuell für das gerade erzeugte oder zerstörte Objekt auf, ist das Verhalten undefiniert, auch wenn die Funktion definiert ist.

Der öffentliche Destruktor virtual ~Strategy() = default; ist explizit als Standardimplementierung definiert und nicht rein virtuell. Er sorgt im Beispiel für die korrekte Zerstörungsreihenfolge, wenn std::unique_ptr<Strategy> ein einzelnes Objekt über Strategy* löscht. Wäre der Destruktor mit = 0 rein virtuell deklariert, wäre bei der Erzeugung abgeleiteter Objekte trotzdem eine Definition außerhalb der Klasse nötig.

print nimmt eine const Strategy& entgegen, statt eine eigene Strategie zu erzeugen. Das ist Dependency Injection: Der virtuelle Aufruf von apply wählt die Implementierung nach dem tatsächlichen Objekttyp. Eine Registry für Fabriken kann zwischen einkompilierten Strategien wählen; virtuelle Aufrufe selbst laden keine dynamischen Bibliotheken.

Beispiele

#include <iostream>
#include <memory>

struct Strategy {
    virtual int apply(int x) const = 0;
    virtual ~Strategy() = default;
};

struct Half : Strategy {
    int apply(int x) const override { return x / 2; }
};

struct Third : Strategy {
    int apply(int x) const override { return x / 3; }
};

void print(const Strategy& strategy) {
    std::cout << strategy.apply(12) << '\n';
}

int main() {
    std::unique_ptr<Strategy> half = std::make_unique<Half>();
    std::unique_ptr<Strategy> third = std::make_unique<Third>();
    print(*half);
    print(*third);
}

Ergebnis

6
4

`Half` teilt `12` durch `2`, `Third` durch `3`. Dieselbe Funktion `print` gibt zuerst `6` und dann `4` aus.

Zugehörige Lektionen

  • C++ · Lektion 59 · Fortgeschritten · Version: 3

Quellen