Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::nullopt — indicare esplicitamente l’assenza di un valore

Usa `std::nullopt` per restituire o svuotare uno `std::optional` senza confondere un risultato mancante con un valore valido come zero.

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

Sintassi

#include <optional>

std::optional<int> no_result() {
    return std::nullopt;
}

void clear(std::optional<int>& result) {
    result = std::nullopt;
}

bool is_empty(const std::optional<int>& result) {
    return result == std::nullopt;
}

std::nullopt è una costante inline constexpr di tipo std::nullopt_t definita nell’header <optional> e disponibile da C++17. Il costruttore che accetta questo marcatore crea uno std::optional<T> vuoto senza costruire un oggetto di tipo T. Usa return std::nullopt; quando una funzione restituisce std::optional<T> e non c’è alcun risultato. La costante non indica il motivo dell’assenza.

o == std::nullopt e !o.has_value() verificano l’assenza di un valore. if (o) verifica la presenza, non il contenuto: anche 0, false o nullptr, se memorizzati, sono valori presenti. Usa *o e o-> solo quando un valore è presente. In C++23 questi operatori hanno un comportamento indefinito su un oggetto vuoto, mentre o.value() lancia std::bad_optional_access. Sia o = std::nullopt sia o.reset() distruggono l’eventuale valore contenuto; non usare più puntatori o riferimenti a quel valore.

Nella lezione 51, std::numeric_limits<int> da <limits> fornisce i limiti di int: max() dà il massimo valore rappresentabile e min() il minimo. Per i tipi in virgola mobile con valori subnormali, min() dà il minimo valore positivo normalizzato; lowest() dà il minimo valore finito. L’esempio verifica il limite appropriato al segno di b prima di valutare a + b. La valutazione a corto circuito di && mantiene le sottrazioni stesse entro l’intervallo. Una somma di tipo int fuori intervallo avrebbe un comportamento indefinito.

Nella lezione 48, std::filesystem::perms da <filesystem> è un tipo di enumerazione enum class che funge da maschera di bit per i permessi dei file. Un valore presente std::filesystem::perms::none indica che nessun bit dei permessi è impostato; uno std::optional<std::filesystem::perms> vuoto indica che non c’è alcun risultato. È solo un contesto d’uso: l’esempio non usa questo tipo e non controlla né fa rispettare i permessi.

Esempi

#include <iostream>
#include <limits>
#include <optional>

std::optional<int> checked_add(int a, int b) {
    using Limits = std::numeric_limits<int>;
    if ((b > 0 && a > Limits::max() - b) ||
        (b < 0 && a < Limits::min() - b)) {
        return std::nullopt;
    }
    return a + b;
}

int main() {
    const auto print = [](std::optional<int> result) {
        if (result) {
            std::cout << *result << '\n';
        } else {
            std::cout << "no result\n";
        }
    };

    print(checked_add(7, -7));
    print(checked_add(std::numeric_limits<int>::max(), 1));
    print(checked_add(std::numeric_limits<int>::min(), -1));
}

Risultato

0
no result
no result

La prima chiamata stampa `0`; le due successive stampano ciascuna `no result` perché la somma non rientra nell’intervallo di `int`.

Lezioni correlate

  • C++ · Lezione 48 · Avanzato · Versione: 3
  • C++ · Lezione 51 · Avanzato · Versione: 3

Fonti