std::optional<T>::optional

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::optional

Funciones miembro

optional::optional

optional::~optional

optional::operator=

Observadores

optional::operator->optional::operator*

optional::operator booloptional::has_value

optional::value

optional::value_or

Modificadores

optional::emplace

optional::swap

optional::reset

Funciones no miembro

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)

make_optional

swap

Guías de deducción

Clases auxiliares

hash

nullopt_t

in_place_t

bad_optional_access

Objetos auxiliares

nullopt

in_place

 

<tbody> </tbody>

constexpr optional() noexcept; constexpr optional( std::nullopt_t ) noexcept;	(1)	(desde C++17)
constexpr optional( const optional& other );	(2)	(desde C++17)
constexpr optional( optional&& other ) noexcept(/* véase más abajo */);	(3)	(desde C++17)
template < class U > optional( const optional<U>& other );	(4)	(desde C++17) (condicionalmente explicit)
template < class U > optional( optional<U>&& other );	(5)	(desde C++17) (condicionalmente explicit)
template< class... Args > constexpr explicit optional( std::in_place_t, Args&&... args );	(6)	(desde C++17)
template< class U, class... Args > constexpr explicit optional( std::in_place_t, std::initializer_list<U> ilist, Args&&... args );	(7)	(desde C++17)
template < class U = value_type > constexpr optional( U&& value );	(8)	(desde C++17) (condicionalmente explicit)

See More

Construye un nuevo objeto optional.

1) Construye un objeto que no contiene un valor.

2) Constructor de copia: Si other contiene un valor, inicializa el valor contenido como si se inicilizara directamente (pero no por inicialización directa de lista) un objeto de tipo T con la expresión *other. Si other no contiene un valor, construye un objeto que no contiene un valor.

• Este constructor se define como eliminado si std::is_copy_constructible_v<T> es false.
• Es un constructor trivial si std::is_trivially_copy_constructible_v<T> es true.

3) Constructor de movimiento: Si other contiene un valor, inicializa el valor contenido como si se inicializara directamente (pero no por inicialización directa de lista) un objeto de tipo T con la expresión std::move(*other) y no hace a other vacío: un {{tt|optional} que ha sido movido aún contiene un valor, pero el valor mismo se ha movido. Si other no contiene un valor, construye un objeto que no contiene un valor.

• Este constructor no participa en la resolución de sobrecargas a menos que std::is_move_constructible_v<T> es true.
• Es un constructor trivial si std::is_trivially_move_constructible_v<T> es true.

4) Constructor de copia de conversión: Si other no contiene un valor, construye un objeto optional que no contiene un valor. De lo contrario, construye un objeto optional que contiene un valor, inicializado como si se inicializara directamente (pero no por inicialización directa de lista) un objeto de tipo T con la expresión *other.

• Este constructor no participa en la resolución de sobrecargas a menos que se cumplan las siguientes condiciones:
  • std::is_constructible_v<T, const U&> es true.
  • T no es construible o es convertible desde cualquier expresión de tipo (posiblemente const) std::optional<U>, es decir, los siguientes 8 rasgos de tipo son todos false:
    • std::is_constructible_v<T, std::optional<U>&>
    • std::is_constructible_v<T, const std::optional<U>&>
    • std::is_constructible_v<T, std::optional<U>&&>
    • std::is_constructible_v<T, const std::optional<U>&&>
    • std::is_convertible_v<std::optional<U>&, T>
    • std::is_convertible_v<const std::optional<U>&, T>
    • std::is_convertible_v<std::optional<U>&&, T>
    • std::is_convertible_v<const std::optional<U>&&, T>
• Este constructor es explicit si y solo si std::is_convertible_v<const U&, T> es false.

5) Constructor de movimiento de conversión: Si other no contiene un valor, construye un objeto optional que no contiene un valor. De lo contrario, construye un objeto optional que contiene un valor, inicializado como si se inicializara directamente (pero no por inicialización directa de lista) un objeto de tipo T con la expresión std::move(*other).

• Este constructor no participa en la resolución de sobrecargas a menos que se cumplan las siguientes condiciones:
  • std::is_constructible_v<T, U&&> es true.
  • T no es construible o es convertible desde cualquier expresión de tipo (posiblemente const) std::optional<U>, es decir, los siguientes 8 rasgos de tipo son todos false:
    • std::is_constructible_v<T, std::optional<U>&>
    • std::is_constructible_v<T, const std::optional<U>&>
    • std::is_constructible_v<T, std::optional<U>&&>
    • std::is_constructible_v<T, const std::optional<U>&&>
    • std::is_convertible_v<std::optional<U>&, T>
    • std::is_convertible_v<const std::optional<U>&, T>
    • std::is_convertible_v<std::optional<U>&&, T>
    • std::is_convertible_v<const std::optional<U>&&, T>
• Este constructor es explicit si y solo si std::is_convertible_v<U&&, T> es false.

6) Construye un objeto optional que contiene un valor, inicializado como si se inicializara directamente (pero no por inicialización directa de lista) un objeto de tipo T de los argumentos std::forward<Args>(args)....

• Si el constructor seleccionado de T es un constructor constexpr, este constructor es un constructor constexpr.
• Esta función no participa en la resolución de sobrecargas a menos que std::is_constructible_v<T, Args...> sea true.

7) Construye un objeto optional que contiene un valor, inicializado como si se inicializara directamente (pero no por inicialización directa de lista) un objeto de tipo T de los argumentos ilist, std::forward<Args>(args)....

• Si el constructor seleccionado de T es un constexpr constructor, este constructor es un constructor constexpr.
• Esta función no participa en la resolución de sobrecargas a menos que std::is_constructible_v<T, std::initializer_list<U>&, Args&&...> sea true.

8) Construye un objeto optional que contiene un valor, inicializado como si se inicializara directamente (pero no por inicialización directa de lista) un objeto de tipo T (where T = value_type) con la expresión std::forward<U>(value).

• Si el constructor seleccionado de T es un constructor constexpr, este constructor es un constructor constexpr.
• Este constructor no participa en la resolución de sobrecargas a menos que std::is_constructible_v<T, U&&> sea true y std::decay_t<U> (hasta C++20)std::remove_cvref_t<U> (desde C++20) no sea ni std::in_place_t ni std::optional<T>.
• Este constructor es explicit si y solo si std::is_convertible_v<U&&, T> es false.

Parámetros

other	-	Otro objeto optional cuyo valor contenido se copia.
value	-	Valor con el cual inicializar el valor contenido.
args...	-	Argumentos con los cuales inicializar el valor contenido.
ilist	-	Lista de inicializadores con la cual inicializar el valor contenido.

Excepciones

2) Lanza cualquier excepción lanzada por el constructor de T.

3) Lanza cualquier excepción lanzada por el constructor de T. Tiene la siguiente

Especificación noexcept:   (desde C++11)

<tbody> </tbody>

noexcept(std::is_nothrow_move_constructible<T>::value)

.

4-8) Lanza cualquier excepción lanzada por el constructor de T.

Guías de deducción

Ejemplo

Ejecuta este código

#include <optional>
#include <iostream>
#include <string>
int main()
{
    std::optional<int> o1, // vacío
                       o2 = 1, // inicializar desde rvalue
                       o3 = o2; // constructor de copia
 
    // llama al constructor de std::string( initializer_list<CharT> )
    std::optional<std::string> o4(std::in_place, {'a', 'b', 'c'});
    
    // llama al constructor de std::string( size_type count, CharT ch )
    std::optional<std::string> o5(std::in_place, 3, 'A');

    // construido por movimiento de std::string usando la guía de deducción para escoger el tipo

    std::optional o6(std::string{"deducción"});
 
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << ' ' << *o5  << ' ' << *o6 << '\n';
}

Salida:

1 1 abc AAA deducción

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
P0602R4	C++17	Los constructores de copia/movimiento pueden no ser triviales incluso si el constructor subyacente es trivial.	Se requirió que propagase la trivialidad.

Véase también

make_optional (C++17)

Crea un objeto opcional (optional). (plantilla de función)