Namespaces
Variants

std::optional<T>:: optional

From cppreference.net
C++
Utilities library
std::optional
constexpr optional ( ) noexcept ;
(1) (seit C++17)
constexpr optional ( std:: nullopt_t ) noexcept ;
(2) (seit C++17)
constexpr optional ( const optional & other ) ;
(3) (seit C++17)
constexpr optional ( optional && other ) noexcept ( /* siehe unten */ ) ;
(4) (seit C++17)
template < class U >
optional ( const optional < U > & other ) ;
(5) (seit C++17)
(constexpr seit C++20)
(bedingt explizit)
template < class U >
optional ( optional < U > && other ) ;
(6) (seit C++17)
(constexpr seit C++20)
(bedingt explizit)
template < class ... Args >
constexpr explicit optional ( std:: in_place_t , Args && ... args ) ;
(7) (seit C++17)
template < class U, class ... Args >

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

Args && ... args ) ;
(8) (seit C++17)
template < class U = std:: remove_cv_t < T > >
constexpr optional ( U && value ) ;
(9) (seit C++17)
(bedingt explizit)

Konstruiert ein neues optional -Objekt.

Inhaltsverzeichnis

Parameter

other - ein anderes optional Objekt, dessen enthaltene Wert kopiert wird
value - Wert, mit dem der enthaltene Wert initialisiert wird
args... - Argumente, mit denen der enthaltene Wert initialisiert wird
ilist - Initialisierungsliste, mit der der enthaltene Wert initialisiert wird

Effekte

Überladung Initialisierungsmethode Initialisierer für den enthaltenen Wert has_value() nach Konstruktion
( 1 ) N/A - false
( 2 )
( 3 ) Direkte (non-list) * other other. has_value ( )
  • Wenn false , wird der enthaltene Wert nicht initialisiert.
( 4 ) std :: move ( * other )
( 5 ) * other
( 6 ) std :: move ( * other )
( 7 ) std:: forward < Args > ( args ) ... true
( 8 ) ilist, std:: forward < Args > ( args ) ...
( 9 ) std:: forward < U > ( value )

Einschränkungen und ergänzende Informationen

3) Wenn std:: is_copy_constructible_v < T > false ist, ist der Konstruktor als gelöscht definiert.
Wenn std:: is_trivially_copy_constructible_v < T > true ist, ist der Konstruktor trivial.
4) Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std:: is_move_constructible_v < T > true ist.
Wenn std:: is_trivially_move_constructible_v < T > true ist, ist der Konstruktor trivial.
5) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
Diese Überladung ist deklariert als ob mit explicit ( ! std:: is_convertible_v < const U & , T > ) .
6) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
Diese Überladung ist deklariert als ob mit explicit ( ! std:: is_convertible_v < U, T > ) .
7) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_constructible_v < T, Args... > true ist.
Wenn T ’s für die Initialisierung ausgewählter Konstruktor ein constexpr -Konstruktor ist, dann ist dieser Konstruktor ebenfalls ein constexpr -Konstruktor.
8) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_constructible_v < T, std:: initializer_list < U > & , Args... > true ist.
Wenn T ’s für die Initialisierung ausgewählter Konstruktor ein constexpr -Konstruktor ist, dann ist dieser Konstruktor ebenfalls ein constexpr -Konstruktor.
9) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
Diese Überladung ist deklariert als ob mit explicit ( ! std:: is_convertible_v < U, T > ) .
Wenn T ’s für die Initialisierung ausgewählter Konstruktor ein constexpr -Konstruktor ist, dann ist dieser Konstruktor ebenfalls ein constexpr -Konstruktor.
  1. ↑ 1.0 1.1 Mit anderen Worten, T ist weder konstruierbar noch konvertierbar von irgendeinem Ausdruck des Typs (möglicherweise const-qualifiziert) std:: optional < U >

Exceptions

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

Deduktionshilfen

Hinweise

Vor der Lösung von LWG Issue 3836 wählte die Konstruktion eines std:: optional < bool > aus std:: optional < U > Überladung ( 9 ) anstelle der Überladungen ( 5,6 ) , falls U nicht bool ist. Dies liegt daran, dass die Überladungen ( 5,6 ) nicht an der Überladungsauflösung teilnahmen, wenn T (in diesem Fall bool ) von std:: optional < U > konstruiert oder konvertiert werden kann, aber std::optional::operator bool die Konversion für jedes U ermöglicht.

Folglich enthält das konstruierte std:: optional < bool > immer einen Wert. Dieser Wert wird dadurch bestimmt, ob das bereitgestellte std:: optional < U > Objekt einen Wert enthält, und nicht durch den bool Wert, der direkt aus dem enthaltenen Wert initialisiert wurde: 

std::optional<bool> op_false(false);
std::optional<int> op_zero(0);
std::optional<int> from_bool(op_false); // OK: enthält 0 (initialisiert von false)
std::optional<bool> from_int(op_zero);  // DEFEKT (LWG 3836): enthält true, weil
                                        // op_zero einen Wert enthält, selbst wenn die
                                        // Initialisierung von bool mit diesem Wert false ergibt
Feature-Test Makro Wert Std Feature
__cpp_lib_optional 202106L (C++20)
(DR20) 		Vollständig constexpr ( 5,6 )

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <optional>
#include <string>
int main()
{
    std::optional<int> o1, // leer
                       o2 = 1, // Initialisierung aus Rvalue
                       o3 = o2; // Kopierkonstruktor
    // Ruft std::string( initializer_list<CharT> ) Konstruktor auf
    std::optional<std::string> o4(std::in_place, {'a', 'b', 'c'});
    // Ruft std::string( size_type count, CharT ch ) Konstruktor auf
    std::optional<std::string> o5(std::in_place, 3, 'A');
    // Move-konstruiert von std::string unter Verwendung des Deduction Guide zur Typauswahl
    std::optional o6(std::string{"deduction"});
    std::cout << *o2 << ' ' << *o3 << ' ' << *o4 << ' ' << *o5  << ' ' << *o6 << '\n';
}

Ausgabe: 

1 1 abc AAA deduction

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3836 C++17 beim Konstruieren eines std:: optional < bool >
aus std:: optional < U > würde die Überladungsauflösung
Überladung ( 9 ) auswählen, falls U nicht bool ist 		wählt in diesem Fall immer den
konvertierenden Kopier-/Move-
Konstruktor aus
LWG 3886 C++17 das Standard-Template-Argument von Überladung ( 9 ) war T geändert zu std:: remove_cv_t < T >
P0602R4 C++17 Kopier-/Move-Konstruktoren könnten nicht trivial sein
selbst wenn der zugrundeliegende Konstruktor trivial ist 		muss
Trivialität weitergeben
P2231R1 C++20 Überladungen ( 5,6 ) von einem anderen std::optional waren nicht constexpr als constexpr festgelegt

Siehe auch

(C++17)
erstellt ein optional -Objekt
(Funktions-Template)