Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Funzione virtuale pura (= 0) in C++

La notazione `= 0` dichiara una funzione membro virtuale pura. Consente di definire un'interfaccia astratta attraverso cui chiamare implementazioni diverse a seconda del tipo dell'oggetto.

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

Sintassi

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

In virtual int apply(int x) const = 0;, = 0 è lo specificatore di purezza, non un'assegnazione né un valore di ritorno. Anche una funzione che ne ridefinisce un'altra può essere virtuale pura: int apply(int x) const override = 0;.

Una classe è astratta se, per almeno una funzione virtuale, la versione finale selezionata per quella classe è ancora pura. Non si può creare un oggetto autonomo di una classe astratta, ma un puntatore o un riferimento di tipo base può riferirsi a un oggetto derivato concreto. override aiuta a rilevare gli errori: senza const, Half::apply non ridefinisce Strategy::apply.

Una funzione virtuale pura può avere una definizione fuori dalla classe e restare pura. Una chiamata qualificata come strategy.Strategy::apply(12) evita il dispatch virtuale e richiede tale definizione. Dal costruttore o dal distruttore di una classe astratta, una chiamata virtuale diretta o indiretta a una funzione virtuale pura sull'oggetto in costruzione o in distruzione ha comportamento indefinito, anche se la funzione è definita.

Il distruttore pubblico virtual ~Strategy() = default; ha una definizione predefinita e non è puro. Garantisce la corretta sequenza di distruzione quando std::unique_ptr<Strategy> elimina un singolo oggetto tramite Strategy*. Se il distruttore fosse dichiarato puro con = 0, servirebbe comunque una definizione fuori dalla classe quando si creano oggetti derivati.

print riceve un riferimento const Strategy& anziché costruire una propria strategia. È iniezione delle dipendenze: la chiamata virtuale ad apply sceglie l'implementazione in base al tipo effettivo dell'oggetto. Un registro di factory può selezionare strategie compilate nel programma; il dispatch virtuale non carica di per sé librerie condivise.

Esempi

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

Risultato

6
4

`Half` divide `12` per `2` e `Third` per `3`. La stessa funzione `print` stampa `6` e poi `4`.

Lezioni correlate

  • C++ · Lezione 59 · Avanzato · Versione: 3

Fonti