Namespaces
Variants

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

    From es.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)