Namespaces
Variants

std:: optional

From cppreference.net
Utilities library
Definido en el encabezado <optional>
template < class T >
class optional ;
(desde C++17)

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

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 en cualquier momento dado o contiene un valor o no contiene un valor .

Si un optional contiene un valor, se garantiza que el valor está anidado dentro del objeto optional . Por lo tanto, un objeto optional modela un objeto, no un puntero, aunque estén definidos operator*() y operator->() .

Cuando un objeto de tipo optional<T> es convertido contextualmente 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/se asigna desde un valor de tipo T u otro optional que contiene un valor.

El objeto no contiene un valor en las siguientes condiciones:

  • El objeto es inicializado por defecto.
  • El objeto es inicializado con/asignado desde un valor de tipo std::nullopt_t o un objeto optional que no contiene un valor.
  • La función miembro reset() es llamada.

El objeto optional es una view que contiene un elemento si contiene un valor , o de lo contrario cero elementos si no contiene un valor. El tiempo de vida del elemento contenido está vinculado al objeto.

(since C++26)

No hay referencias opcionales, funciones, arrays, o (posiblemente calificados cv) void ; un programa está mal formado si instancia un optional con tal tipo. Además, un programa está mal formado si instancia un optional con los tipos de etiqueta (posiblemente calificados cv) std::nullopt_t o std::in_place_t .

Contenidos

Parámetros de plantilla

T - el tipo del valor para gestionar el estado de inicialización. El tipo debe cumplir con los requisitos de Destructible (en particular, los tipos array y referencia no están permitidos).

Tipos anidados

Tipo Definición
value_type T
iterator (desde C++26) definido por la implementación LegacyRandomAccessIterator , ConstexprIterator , y contiguous_iterator cuyo value_type y reference son std:: remove_cv_t < T > y T & , respectivamente.
const_iterator (desde C++26) definido por la implementación LegacyRandomAccessIterator , ConstexprIterator , y contiguous_iterator cuyo value_type y reference son std:: remove_cv_t < T > y const T & , respectivamente.

Todos los requisitos sobre los tipos de iterador de un Container se aplican también al tipo iterator de optional .

Miembros de datos

T* val un puntero al objeto contenido (si existe)
( objeto miembro solo para exposición* )

Funciones miembro

construye el objeto optional
(función miembro pública)
destruye el valor contenido, si existe
(función miembro pública)
asigna contenidos
(función miembro pública)
Iteradores
(C++26)
devuelve un iterador al inicio
(función miembro pública)
(C++26)
devuelve un iterador al final
(función miembro pública)
Observadores
accede al valor contenido
(función miembro pública)
comprueba si el objeto contiene un valor
(función miembro pública)
devuelve el valor contenido
(función miembro pública)
devuelve el valor contenido si está disponible, otro valor en caso contrario
(función miembro pública)
Operaciones monádicas
(C++23)
devuelve el resultado de la función dada sobre el valor contenido si existe, o un optional vacío en caso contrario
(función miembro pública)
(C++23)
devuelve un optional que contiene el valor contenido transformado si existe, o un optional vacío en caso contrario
(función miembro pública)
(C++23)
devuelve el propio optional si contiene un valor, o el resultado de la función dada en caso contrario
(función miembro pública)
Modificadores
intercambia los contenidos
(función miembro pública)
destruye cualquier valor contenido
(función miembro pública)
construye el valor contenido in situ
(función miembro pública)

Funciones no miembro

(C++17) (C++17) (C++17) (C++17) (C++17) (C++17) (C++20)
compara objetos optional
(plantilla de función)
crea un objeto optional
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)

Clases auxiliares

soporte de hash para std::optional
(especialización de plantilla de clase)
(C++17)
indicador de un std::optional que no contiene un valor
(clase)
excepción que indica acceso verificado a un optional que no contiene un valor
(clase)

Asistentes

(C++17)
un objeto de tipo nullopt_t
(constante)
etiqueta de construcción in situ
(etiqueta)

Especializaciones auxiliares

template < class T >
constexpr bool ranges:: enable_view < std :: optional < T >> = true ;
(desde C++26)

Esta especialización de ranges::enable_view hace que optional satisfaga view .

template < class T >
constexpr auto format_kind < std :: optional < T >> = range_format :: disabled ;
(desde C++26)

Esta especialización de format_kind desactiva el soporte de formato de rangos de optional .

Guías de deducción

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_optional 201606L (C++17) std::optional
202106L (C++23)
(DR20)
Completamente constexpr
202110L (C++23) Operaciones mónadas
__cpp_lib_optional_range_support 202406L (C++26) Soporte de rangos para std::optional

Ejemplo

#include <iostream>
#include <optional>
#include <string>
// optional puede usarse como tipo de retorno de una fábrica que puede fallar
std::optional<std::string> create(bool b)
{
    if (b)
        return "Godzilla";
    return {};
}
// std::nullopt puede usarse para crear cualquier std::optional (vacío)
auto create2(bool b)
{
    return b ? std::optional<std::string>{"Godzilla"} : std::nullopt;
}
int main()
{
    std::cout << "create(false) returned "
              << create(false).value_or("empty") << '\n';
    // las funciones fábrica que retornan optional son utilizables como condiciones de while e if
    if (auto str = create2(true))
        std::cout << "create2(true) returned " << *str << '\n';
}

Salida:

create(false) returned empty
create2(true) returned Godzilla

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 4141 C++17 el requisito de asignación de almacenamiento
era confuso
el objeto contenido debe estar
anidado dentro del objeto optional

Véase también

(C++17)
una unión discriminada type-safe
(plantilla de clase)
(C++17)
objetos que contienen instancias de cualquier tipo CopyConstructible
(clase)
(C++23)
un wrapper que contiene un valor esperado o un error
(plantilla de clase)
un view que contiene un único elemento de un valor especificado
(plantilla de clase) (objeto de punto de personalización)
un view vacío sin elementos
(plantilla de clase) (plantilla de variable)