Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::optional — un valore che può essere assente

std::optional<T> rappresenta un oggetto di tipo T oppure l’assenza di un valore. Permette di distinguere un risultato mancante da valori validi come 0. Verifica che sia presente un valore prima di usare gli operatori * e ->.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <optional>
std::optional<T> item;
std::optional<T> empty = std::nullopt;
if (item) { /* *item; item->member; */ }

std::optional<T>, dichiarato in <optional>, memorizza un valore di tipo T nel proprio oggetto oppure non contiene alcun valore. È utile quando una funzione può non restituire un risultato, ma non serve una descrizione dell’errore. La costruzione predefinita con std::optional<T> item; produce uno stato vuoto; la costruzione a partire da un valore di tipo T produce uno stato che contiene un valore.

std::nullopt è la costante che indica l’assenza di un valore e std::nullopt_t è il suo tipo tag distinto, non il tipo del risultato memorizzato. Usa return std::nullopt; per restituire un risultato vuoto oppure item = std::nullopt; per rimuovere il valore memorizzato.

std::optional::operator bool è una conversione esplicita che verifica la presenza di un valore; funziona in if (item), in modo simile a item.has_value(). Non verifica il valore memorizzato in sé: un oggetto che contiene 0 o false restituisce comunque true.

std::optional::operator* fornisce il valore memorizzato tramite un riferimento, mentre std::optional::operator-> consente di accedere ai suoi membri. Entrambi richiedono che sia presente un valore. In C++23, usarli su un oggetto vuoto ha comportamento indefinito; non aspettarti un’eccezione. Il metodo value() verifica questo stato e genera std::bad_optional_access quando non è presente alcun valore.

Questa voce riguarda C++23: l’opzione del compilatore usata nel repository, senza attestazione dell’ambiente di esecuzione di produzione. La bozza di lavoro collegata viene aggiornata e include anche estensioni successive; il suo intero contenuto non deve essere considerato C++23.

Esempi

#include <iostream>
#include <optional>

struct Item {
    int count;
};

std::optional<Item> find_item(bool available) {
    if (available) {
        return Item{0};
    }
    return std::nullopt;
}

int main() {
    const auto item = find_item(true);
    if (item) {
        std::cout << item->count << ' ' << (*item).count << '\n';
    }

    const auto missing = find_item(false);
    std::cout << std::boolalpha << missing.has_value() << '\n';
}

Risultato

0 0
false

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti