Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::optional::operator*: acceso al valor contenido

`*opt` devuelve una referencia al valor contenido. Comprueba que haya un valor antes de desreferenciar: el índice `0` es válido y no indica ausencia.

Versión: ISO C++23; implementation support may vary

Sintaxis

// In <optional>, members of std::optional<T>:
constexpr T& operator*() & noexcept;
constexpr const T& operator*() const & noexcept;
constexpr T&& operator*() && noexcept;
constexpr const T&& operator*() const && noexcept;

// Use: *opt, with opt.has_value() == true.

std::optional::operator* se declara en <optional> y está disponible desde C++17. La expresión *opt devuelve una referencia al objeto almacenado en un std::optional<T>; la llamada no copia ni mueve ese objeto. No es un acceso por índice ni la desreferenciación de un puntero sin encapsular.

Antes de desreferenciar, comprueba if (opt) o opt.has_value(). La conversión contextual a bool comprueba si hay un valor, no cuál es: el índice 0 pasa la comprobación, pero un opcional vacío no. En C++23, desreferenciar un opcional vacío provoca comportamiento indefinido. No confíes en que la implementación detecte el error. Si la ausencia debe producir una excepción, usa opt.value(), que en ese caso lanza std::bad_optional_access.

Las cuatro sobrecargas son constexpr y noexcept. Un lvalue devuelve T&, o const T& si es const. Un rvalue devuelve T&&, o const T&& si es const. Puedes modificar el objeto almacenado a través de T&. Por sí solo, *std::move(opt) no mueve el objeto ni vacía opt.

La referencia devuelta no prolonga la vida del objeto almacenado. No la uses tras opt.reset() ni después de que se destruya opt. Un opcional temporal normalmente se destruye al terminar la expresión completa que lo creó, pero vincular una referencia distinta al propio opcional puede prolongar su vida.

Ejemplos

#include <cstddef>
#include <iostream>
#include <optional>

void print_index(const std::optional<std::size_t>& index)
{
    if (index) {
        std::cout << "index: " << static_cast<unsigned long long>(*index) << '\n';
    } else {
        std::cout << "not found\n";
    }
}

int main()
{
    const std::optional<std::size_t> first{0};
    const std::optional<std::size_t> missing{std::nullopt};
    print_index(first);
    print_index(missing);
}

Resultado

index: 0
not found

`if (index)` reconoce el índice `0` como presente. Con `std::nullopt`, el programa imprime `not found` sin desreferenciar.

Lecciones relacionadas

  • C++ · Lección 51 · Avanzado · Versión: 3

Fuentes