CKTIS / C++
std::optional::operator-> — acceso a un miembro del valor contenido
Usa `->` para acceder a un miembro del valor almacenado en `std::optional`. En C++23, comprueba que el valor esté presente antes de usar el operador.
Versión: ISO C++23; implementation support may vary
Sintaxis
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-> está disponible en <optional> desde C++17. En opt->member, C++ llama al operador sobrecargado y después aplica el -> incorporado al puntero devuelto. El operador devuelve T* para un std::optional<T> no const y const T* para uno const. Ambas sobrecargas son constexpr y noexcept; ninguna copia el valor.
En C++23, llamar al operador sobre un optional vacío tiene comportamiento indefinido: no esperes nullptr ni una excepción. Usa if (opt) u opt.has_value() y accede al valor solo mientras siga presente. if (opt) usa el operator bool explícito en una conversión contextual: comprueba la presencia, no el valor en sí. Para un acceso con comprobación, opt.value() lanza std::bad_optional_access si no hay valor.
*opt da una referencia en lugar de un puntero y también requiere que haya un valor. El puntero de operator-> no es propietario ni prolonga el tiempo de vida del valor. No lo uses para acceder al valor después de que termine su tiempo de vida, por ejemplo tras llamar a reset() o destruir el optional.
En el ejemplo, fs es un alias del espacio de nombres std::filesystem. El & de const std::optional<fs::path>& borrowedpath declara una referencia a lvalue de tipo calificado con const: el parámetro no copia el optional y -> selecciona la sobrecarga const. Una ruta vacía sigue siendo un valor presente; path::empty() no consulta el sistema de archivos.
Ejemplos
#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);
}
Resultado
empty path no value
La primera llamada imprime `empty path` porque hay un valor, pero la ruta está vacía. La segunda imprime `no value` y no evalúa `->`.
Lecciones relacionadas
- C++ · Lección 48 · Avanzado · Versión: 3