Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Czysto wirtualna funkcja (= 0) w C++

Zapis `= 0` oznacza czysto wirtualną funkcję składową. Pozwala zdefiniować abstrakcyjny interfejs, przez który można wywoływać różne implementacje zależnie od typu obiektu.

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

Składnia

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

W deklaracji virtual int apply(int x) const = 0; zapis = 0 to specyfikator czystości, a nie przypisanie ani instrukcja zwracająca zero. Funkcja, która przesłania funkcję bazową, też może być czysto wirtualna: int apply(int x) const override = 0;.

Klasa jest abstrakcyjna, jeśli dla co najmniej jednej funkcji wirtualnej jej ostateczna wersja w tej klasie pozostaje czysto wirtualna. Nie można utworzyć samodzielnego obiektu takiej klasy, ale wskaźnik lub referencja typu bazowego mogą wskazywać na obiekt klasy konkretnej. override wykrywa pomyłki: brak const w Half::apply oznacza, że funkcja nie przesłania Strategy::apply.

Funkcję czysto wirtualną można zdefiniować poza klasą; nie przestaje przez to być czysto wirtualna. Kwalifikowane wywołanie strategy.Strategy::apply(12) omija mechanizm wywołania wirtualnego i wymaga tej definicji. Bezpośrednie lub pośrednie wywołanie wirtualne funkcji czysto wirtualnej na konstruowanym lub niszczonym obiekcie z konstruktora lub destruktora klasy abstrakcyjnej ma niezdefiniowane zachowanie, nawet jeśli funkcja ma definicję.

Publiczny destruktor virtual ~Strategy() = default; ma definicję domyślną i nie jest czysto wirtualny. Zapewnia właściwą kolejność niszczenia w przykładzie: std::unique_ptr<Strategy> usuwa pojedynczy obiekt przez Strategy*. Gdyby destruktor zadeklarowano jako czysto wirtualny za pomocą = 0, nadal trzeba by go zdefiniować poza klasą, gdy tworzone są obiekty pochodne.

print otrzymuje strategię jako const Strategy&, zamiast samodzielnie ją tworzyć. To wstrzykiwanie zależności: wywołanie apply wybiera implementację według rzeczywistego typu obiektu. Rejestr fabryk może wybierać spośród strategii wkompilowanych w program; sam mechanizm wywołań wirtualnych nie ładuje bibliotek dynamicznych.

Przykłady

#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);
}

Wynik

6
4

`Half` dzieli `12` przez `2`, a `Third` przez `3`. Ta sama funkcja `print` wypisuje `6`, a następnie `4`.

Powiązane lekcje

  • C++ · Lekcja 59 · Zaawansowany · Wersja: 3

Źródła