Namespaces
Variants

std::experimental::optional<T>:: optional

From cppreference.net
C++
Experimental
Library fundamentals
std::experimental::optional
constexpr optional ( ) noexcept ;
constexpr optional ( std:: experimental :: nullopt_t ) noexcept ;
(1) (biblioteca de fundamentos TS)
optional ( const optional & other ) ;
(2) (biblioteca de fundamentos TS)
optional ( optional && other ) noexcept ( /* ver más abajo */ ) ;
(3) (biblioteca de fundamentos TS)
constexpr optional ( const T & value ) ;
(4) (biblioteca de fundamentos TS)
constexpr optional ( T && value ) ;
(5) (biblioteca de fundamentos TS)
template < class ... Args >
constexpr explicit optional ( std:: experimental :: in_place_t , Args && ... args ) ;
(6) (biblioteca de fundamentos TS)
template < class U, class ... Args >

constexpr explicit optional ( std:: experimental :: in_place_t ,
std:: initializer_list < U > ilist,

Args && ... args ) ;
(7) (biblioteca de fundamentos TS)

Construye un nuevo objeto optional .

1) Construye el objeto que no contiene un valor .
2) Constructor de copia: Si other contiene un valor, inicializa el valor contenido como si direct-initializing (pero no direct-list-initializing) un objeto de tipo T con la expresión * other . Si other no contiene un valor, construye un objeto que no contiene un valor .
3) Constructor de movimiento: Si other contiene un valor, inicializa el valor contenido como si inicializara directamente (pero no inicialización directa de lista) un objeto de tipo T con la expresión std :: move ( * other ) y no vacía other : un optional movido aún contiene un valor , pero el valor en sí ha sido movido. Si other no contiene un valor, construye un objeto que no contiene un valor .
4) Construye un objeto opcional que contiene un valor , inicializado como si se inicializara directamente (pero no mediante inicialización de lista directa) un objeto de tipo T con la expresión value . Este constructor es constexpr si el constructor de T seleccionado por la inicialización directa es constexpr .
5) Construye un objeto opcional que contiene un valor , inicializado como si se inicializara directamente (pero no mediante inicialización de lista directa) un objeto de tipo T con la expresión std :: move ( value ) . Este constructor es constexpr si el constructor de T seleccionado por la inicialización directa es constexpr .
6) Construye un objeto opcional que contiene un valor , inicializado como si direct-initializing (pero no direct-list-initializing) un objeto de tipo T a partir de los argumentos std:: forward < Args > ( args ) ... .
7) Construye un objeto opcional que contiene un valor , inicializado como si se inicializara directamente (pero no mediante inicialización de lista directa) un objeto de tipo T a partir de los argumentos ilist, std:: forward < Args > ( args ) ... . La función no participa en la resolución de sobrecarga si std:: is_constructible < T, std:: initializer_list < U > & , Args && ... > :: value ! = true .

Contenidos

Parámetros

other - otro objeto optional cuyo valor contenido se copiará
value - valor con el que inicializar el valor contenido
args... - argumentos con los que inicializar el valor contenido
ilist - lista de inicialización con la que inicializar el valor contenido
Requisitos de tipo
-
T debe cumplir con los requisitos de CopyConstructible para usar las sobrecargas (2,4).
-
T debe cumplir con los requisitos de MoveConstructible para usar las sobrecargas (3,5).

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 declaración noexcept :
noexcept specification:
noexcept ( std:: is_nothrow_move_constructible < T > :: value )
4-7) Lanza cualquier excepción lanzada por el constructor de T .

Ejemplo

Ejecutar este código 
#include <experimental/optional>
#include <iostream>
#include <string>
int main()
{
    std::experimental::optional<int> o1,      // vacío
                                     o2 = 1,  // inicializado desde valor-R
                                     o3 = o2; // constructor de copia
    std::experimental::optional<std::string> o4(std::experimental::in_place,
                                                {'a', 'b', 'c'});
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << '\n';
}

Salida: 

1 1 abc

Véase también

crea un objeto optional
(plantilla de función)