CKTIS / C++
std::optional::operator-> — accesso a un membro del valore contenuto
Usa `->` per accedere a un membro del valore memorizzato in `std::optional`. In C++23 devi prima verificare che il valore sia presente.
Versione: ISO C++23; implementation support may vary
Sintassi
In <optional>, std::optional<T> declares:
constexpr T* operator->() noexcept;
constexpr const T* operator->() const noexcept;
Member access: opt->member or opt->method(args...)
C++23 precondition: opt.has_value() is true when operator->() is called.std::optional::operator-> è disponibile in <optional> da C++17. In opt->member, C++ chiama l’operatore sovraccaricato e poi applica il -> predefinito al puntatore restituito. L’operatore restituisce T* per uno std::optional<T> non const e const T* per uno const. Entrambi gli overload sono constexpr e noexcept; nessuno copia il valore.
In C++23 chiamare l’operatore su un optional vuoto ha comportamento indefinito: non aspettarti né nullptr né un’eccezione. Usa if (opt) oppure opt.has_value() e accedi al valore solo finché è presente. if (opt) usa l’operator bool esplicito in una conversione contestuale: verifica la presenza, non il valore in sé. Per un accesso con controllo, opt.value() lancia std::bad_optional_access se il valore è assente.
*opt fornisce un riferimento anziché un puntatore e richiede anch’esso un valore presente. Il puntatore restituito da operator-> non possiede il valore e non ne prolunga la durata di vita. Non usarlo per accedere al valore dopo la fine della sua durata di vita, per esempio dopo reset() o la distruzione dell’optional.
Nell’esempio fs è un alias del namespace std::filesystem. Il simbolo & in const std::optional<fs::path>& borrowedpath dichiara un riferimento lvalue a un tipo qualificato const: il parametro non copia l’optional e -> seleziona l’overload const. Un percorso vuoto è comunque un valore presente; path::empty() non interroga il file system.
Esempi
#include <filesystem>
#include <iostream>
#include <optional>
#include <utility>
namespace fs = std::filesystem;
void describe(const std::optional<fs::path>& borrowedpath)
{
if (borrowedpath) {
std::cout << (borrowedpath->empty() ? "empty path\n" : "nonempty path\n");
} else {
std::cout << "no value\n";
}
}
int main()
{
const std::optional<fs::path> present{std::in_place};
const std::optional<fs::path> absent;
describe(present);
describe(absent);
}
Risultato
empty path no value
La prima chiamata stampa `empty path` perché il valore è presente, ma il percorso è vuoto. La seconda stampa `no value` senza valutare `->`.
Lezioni correlate
- C++ · Lezione 48 · Avanzato · Versione: 3