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) (Bibliothek Fundamentals TS)
optional ( const optional & other ) ;
(2) (Bibliothek Fundamentals TS)
optional ( optional && other ) noexcept ( /* siehe unten */ ) ;
(3) (Bibliothek Fundamentals TS)
constexpr optional ( const T & value ) ;
(4) (Bibliothek Fundamentals TS)
constexpr optional ( T && value ) ;
(5) (Bibliothek Fundamentals TS)
template < class ... Args >
constexpr explicit optional ( std:: experimental :: in_place_t , Args && ... args ) ;
(6) (Bibliothek Fundamentals TS)
template < class U, class ... Args >

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

Args && ... args ) ;
(7) (Bibliothek Fundamentals TS)

Konstruiert ein neues optional -Objekt.

1) Konstruiert das Objekt, das keinen Wert enthält .
2) Kopierkonstruktor: Wenn other einen Wert enthält, initialisiert er den enthaltenen Wert als ob Direktinitialisierung (aber keine direkte Listeninitialisierung) eines Objekts vom Typ T mit dem Ausdruck * other durchgeführt würde. Wenn other keinen Wert enthält, konstruiert er ein Objekt, das keinen Wert enthält .
3) Move-Konstruktor: Wenn other einen Wert enthält, initialisiert er den enthaltenen Wert als ob Direktinitialisierung (aber keine direkte Listeninitialisierung) eines Objekts vom Typ T mit dem Ausdruck std :: move ( * other ) durchgeführt würde und macht other nicht leer: Ein verschobenes Optional enthält weiterhin einen Wert , aber der Wert selbst wurde verschoben. Wenn other keinen Wert enthält, konstruiert er ein Objekt, das keinen Wert enthält .
4) Konstruiert ein optional-Objekt, das einen Wert enthält , initialisiert als ob Direct-Initialisierung (aber nicht Direct-List-Initialisierung) eines Objekts vom Typ T mit dem Ausdruck value durchgeführt würde. Dieser Konstruktor ist constexpr , wenn der durch Direct-Initialisierung ausgewählte Konstruktor von T constexpr ist.
5) Konstruiert ein optional-Objekt, das einen Wert enthält , initialisiert als ob Direct-Initialisierung (aber nicht Direct-List-Initialisierung) eines Objekts vom Typ T mit dem Ausdruck std :: move ( value ) durchgeführt würde. Dieser Konstruktor ist constexpr , wenn der durch Direct-Initialisierung ausgewählte Konstruktor von T constexpr ist.
6) Konstruiert ein optionales Objekt, das einen Wert enthält , initialisiert als ob Direct-Initialisierung (aber nicht Direct-List-Initialisierung) eines Objekts vom Typ T mit den Argumenten std:: forward < Args > ( args ) ... .
7) Konstruiert ein optional-Objekt, das einen Wert enthält , initialisiert als ob Direct-Initialisierung (aber nicht Direct-List-Initialisierung) eines Objekts vom Typ T mit den Argumenten ilist, std:: forward < Args > ( args ) ... . Die Funktion nimmt nicht an der Überladungsauflösung teil, falls std:: is_constructible < T, std:: initializer_list < U > & , Args && ... > :: value ! = true .

Inhaltsverzeichnis

Parameter

other - ein weiteres optional -Objekt, dessen enthaltenen Wert kopiert werden soll
value - Wert zur Initialisierung des enthaltenen Werts
args... - Argumente zur Initialisierung des enthaltenen Werts
ilist - Initialisierungsliste zur Initialisierung des enthaltenen Werts
Typanforderungen
-
T muss die Anforderungen von CopyConstructible erfüllen, um die Überladungen (2,4) verwenden zu können.
-
T muss die Anforderungen von MoveConstructible erfüllen, um die Überladungen (3,5) verwenden zu können.

Exceptions

2) Wirft jede Ausnahme, die vom Konstruktor von T geworfen wird.
3) Wirft jede Ausnahme, die vom Konstruktor von T geworfen wird. Hat die folgende noexcept -Deklaration:
noexcept -Spezifikation:
noexcept ( std:: is_nothrow_move_constructible < T > :: value )
4-7) Wirft jede Ausnahme, die vom Konstruktor von T geworfen wird.

Beispiel

Diesen Code ausführen 
#include <experimental/optional>
#include <iostream>
#include <string>
int main()
{
    std::experimental::optional<int> o1,      // leer
                                     o2 = 1,  // Initialisierung aus R-Wert
                                     o3 = o2; // Kopierkonstruktor
    std::experimental::optional<std::string> o4(std::experimental::in_place,
                                                {'a', 'b', 'c'});
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << '\n';
}

Ausgabe: 

1 1 abc

Siehe auch

erstellt ein optional -Objekt
(Funktions-Template)