std::optional - cppreference.com

La plantilla de clase std::optional gestiona un valor contenido opcional, p.ej., un valor que puede o no estar presente.

Un caso de uso común para optional es el valor de retorno de una función que puede fallar. A diferencia de otros enfoques, como std::pair<T,bool>, optional maneja bien los objetos costosos de construir y es más legible, ya que la intención se expresa explícitamente .

Cualquier instancia de optional<T> en cualquier momento dado, contiene un valor o no contiene un valor.

Si un optional<T> contiene un valor, se garantiza que el valor se asignará como parte del espacio ocupado del objeto optional, es decir, nunca se realiza una asignación de memoria dinámica. Por lo tanto, un objeto optional modela un objeto, no un puntero, aunque operator*() y operator->() están definidos.

Cuando un objeto de tipo optional<T> es contextualmente convertido a bool, la conversión devuelve true si el objeto contiene un valor y false si no contiene un valor.

El objeto optional contiene un valor en las siguientes condiciones:

• El objeto se inicializa con, o es asignado desde un valor de tipo T u otro optional que contiene un valor.

El objeto optional no contiene un valor en las siguientes condiciones:

• El objeto está inicializado por defecto.
• El objeto se inicializa con/es asignado a partir de un valor de tipo std::nullopt_t o un objeto optional que no contiene un valor.
• Se llama a la función miembro reset().

No hay referencias opcionales; un programa está mal formado si crea una instancia de optional con un tipo referencia. Alternativamente, un optional de un std::reference_wrapper del tipo T puede usarse para contener una referencia. Además, un programa está mal formado si crea una instancia de optional con los tipos etiqueta (posiblemente calificados-cv) std::nullopt_t o std::in_place_t.

Parámetros de plantilla

Tipos miembro

Funciones miembro

Funciones no miembro

Clases auxiliares

Objetos auxiliares

Guías de deducción

Ejemplo

#include <string>
#include <functional>
#include <iostream>
#include <optional>
 
// optional puede usarse como el tipo de retorno de una fábrica que puede fallar
std::optional<std::string> crear(bool b) {
    if (b)
        return "Godzilla";
    return {};
}

// std::nullopt puede usarse para crear cualquier std::optional (vacío)
auto crear2(bool b) {
    return b ? std::optional<std::string>{"Godzilla"} : std::nullopt;
}

// std::reference_wrapper puede usarse para devolver una referencia
auto crear_ref(bool b) {
    static std::string value = "Godzilla";
    return b ? std::optional<std::reference_wrapper<std::string>>{value}
             : std::nullopt;
}

int main()
{
    std::cout << "crear(false) devolvió "
              << crear(false).value_or("vacío") << '\n';
 
    // funciones fábrica que devuelven un opcional son utilizables como condiciones
    // para las instrucciones while e if
    if (auto str = crear2(true)) {
        std::cout << "crear2(true) devolvió " << *str << '\n';
    }

    if (auto str = crear_ref(true)) {
        // usar get() para acceder al valor de reference_wrapper
        std::cout << "crear_ref(true) devolvió " << str->get() << '\n';
        str->get() = "Mothra";
        std::cout << "al modificarlo cambió a " << str->get() << '\n';
    }
}

crear(false) devolvió vacío
crear2(true) devolvió Godzilla
crear_ref(true) devolvió Godzilla
al modificarlo cambió a Mothra

Véase también