Namespaces
Variants

    Zuweisbarer Wrapper (C++20)

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsanpasser
     
    template< class T >
    requires std::copy_constructible<T> && std::is_object_v<T>
class /*copyable-box*/;
    		(seit C++20)
    (bis C++23)
    (nur zur Veranschaulichung*)    		 
    template< class T >
    requires std::move_constructible<T> && std::is_object_v<T>
class /*movable-box*/;
    		(seit C++23)
    (nur zur Veranschaulichung*)

    ranges::single_view, ranges::repeat_view,(seit C++23) und Bereichsanpasser, die ein aufrufbares Objekt speichern, werden anhand einer nur zur Veranschaulichung dienenden Klassenvorlage spezifiziert copyable-box(bis C++23)movable-box(seit C++23). Der hier gezeigte Name dient nur zur Veranschaulichung.

    Der Wrapper verhält sich genau wie std::optional<T>, außer dass der Standardkonstruktor, der Kopierzuweisungsoperator und der Verschiebezuweisungsoperator (bedingt) unterschiedlich zu denen von std::optional sind, wodurch T mit Zuweisbarkeit erweitert wird, wenn nötig, und es immer copyableoder movable(seit C++23) erfüllt.

    Wenn T bereits copyable ist, oder sowohl std::is_nothrow_move_constructible_v<T> als auch std::is_nothrow_copy_constructible_v<T> true sind, kann /*copyable-box*/<T> nur ein T Objekt speichern, da es immer einen Wert enthält.

    		 (bis C++23)

    Wenn T

    /*movable-box*/<T> kann nur ein T Objekt speichern, da es immer einen Wert enthält.

    		(seit C++23)

    Template-Parameter

    T - der Typ des enthaltenen Werts, muss ein Objekttyp sein, der copy_constructible (bis C++23) move_constructible (seit C++23) modelliert

    Memberfunktionen

    Standardkonstruktor

    constexpr /*copyable-box*/ ( ) noexcept ( std:: is_nothrow_default_constructible_v < T > )

    requires std:: default_initializable < T >

    : /*copyable-box*/ ( std:: in_place ) { }
    		(seit C++20)
    (bis C++23)
    constexpr /*movable-box*/ ( ) noexcept ( std:: is_nothrow_default_constructible_v < T > )

    requires std:: default_initializable < T >

    : /*movable-box*/ ( std:: in_place ) { }
    		(seit C++23)

    Der Standardkonstruktor wird bereitgestellt, wenn und nur wenn T das Konzept default_initializable modelliert.

    Ein standardkonstruierter Wrapper enthält einen wertinitialisierten T -Objekt.

    Zuweisungsoperatoren

    (1)
    constexpr /*copyable-box*/ & operator = ( const /*copyable-box*/ & other ) ;
    noexcept ( /* siehe unten */ ) ;
    		(seit C++20)
    (bis C++23)
    constexpr /*movable-box*/ & operator = ( const /*movable-box*/ & other ) ;
    noexcept ( /* siehe unten */ ) requires std:: copy_constructible < T > ;
    		(seit C++23)
    (2)
    constexpr /*copyable-box*/ & operator = ( /*copyable-box*/ && other )
    noexcept ( std:: is_nothrow_move_constructible_v < T > ) ;
    		(seit C++20)
    (bis C++23)
    constexpr /*movable-box*/ & operator = ( /*movable-box*/ && other )
    noexcept ( std:: is_nothrow_move_constructible_v < T > ) ;
    		(seit C++23)
    1) Falls std:: copyable < T > nicht modelliert wird, ist der Kopierzuweisungsoperator äquivalent definiert als:

    constexpr /*copyable-box*/ & operator = ( const /*copyable-box*/ & other )
    noexcept ( std:: is_nothrow_copy_constructible_v < T > )
    {
    if ( this ! = std:: addressof ( other ) )
    if ( other )
    emplace ( * other ) ;
    else
    reset ( ) ;

    return * this ;
    }

    		(bis C++23)

    constexpr /*movable-box*/ & operator = ( const /*movable-box*/ & other )
    noexcept ( std:: is_nothrow_copy_constructible_v < T > )
    requires std:: copy_constructible < T >
    {
    if ( this ! = std:: addressof ( other ) )
    if ( other )
    emplace ( * other ) ;
    else
    reset ( ) ;

    return * this ;
    }

    		(seit C++23)
    Andernfalls ist er identisch mit dem Kopierzuweisungsoperator von std::optional .
    2) Falls std:: movable < T > nicht modelliert wird, ist der Move-Zuweisungsoperator äquivalent definiert als:

    constexpr /*copyable-box*/ & operator = ( /*copyable-box*/ && other )
    noexcept ( std:: is_nothrow_move_constructible_v < T > )
    {
    if ( this ! = std:: addressof ( other ) )
    if ( other )
    emplace ( std :: move ( * other ) ) ;
    else
    reset ( ) ;

    return * this ;
    }

    		(bis C++23)

    constexpr /*movable-box*/ & operator = ( /*movable-box*/ && other )
    noexcept ( std:: is_nothrow_move_constructible_v < T > )
    {
    if ( this ! = std:: addressof ( other ) )
    if ( other )
    emplace ( std :: move ( * other ) ) ;
    else
    reset ( ) ;

    return * this ;
    }

    		(seit C++23)
    Andernfalls ist er identisch mit dem Move-Zuweisungsoperator von std::optional .

    Mitglieder identisch mit std:: optional

    Elementfunktionen

    		konstruiert das optional -Objekt
    (öffentliche Elementfunktion von std::optional<T> )
    		zerstört den enthaltenen Wert, falls vorhanden
    (öffentliche Elementfunktion von std::optional<T> )
    		weist Inhalte zu
    (öffentliche Elementfunktion von std::optional<T> )
    Beobachter
    		greift auf den enthaltenen Wert zu
    (öffentliche Elementfunktion von std::optional<T> )
    		prüft, ob das Objekt einen Wert enthält
    (öffentliche Elementfunktion von std::optional<T> )
    Modifikatoren
    		zerstört jeden enthaltenen Wert
    (öffentliche Elementfunktion von std::optional<T> )
    		konstruiert den enthaltenen Wert direkt
    (öffentliche Elementfunktion von std::optional<T> )

    Hinweise

    Ein copyable-box (bis C++23) movable-box (seit C++23) enthält nur dann keinen Wert, wenn

    • T modelliert nicht movable oder copyable , und eine Ausnahme wird bei Move-Zuweisung bzw. Copy-Zuweisung ausgelöst, oder
    • es wird von einem anderen wertlosen Wrapper initialisiert/zugewiesen.

    Vor P2325R3 wurde der Wrapper im Standard als semiregular-box bezeichnet und erfüllte stets semiregular , da der Standardkonstruktor immer bereitgestellt wurde (was einen wertlosen Wrapper konstruieren könnte).

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges 201911L (C++20) Ranges-Bibliothek und constrained algorithms
    202106L (C++20)
    (DR)     		Nicht- default-initializable Views
    202207L (C++23) Lockerung der Range-Adapter für move-only Typen

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    P2325R3 C++20 falls T nicht default_initializable ist, konstruiert der Standardkonstruktor
    einen Wrapper, der keinen Wert enthält     		der Wrapper ist ebenfalls
    nicht default_initializable
    LWG 3572 C++20 bedingt unterschiedliche Zuweisungsoperatoren waren nicht constexpr als constexpr festgelegt

    Siehe auch

    (C++20)
    		eine view , die ein einzelnes Element eines bestimmten Wertes enthält
    (Klassentemplate) (Anpassungspunktobjekt)
    (C++23)
    		eine view , die aus einer generierten Sequenz besteht, indem wiederholt derselbe Wert erzeugt wird
    (Klassentemplate) (Anpassungspunktobjekt)
    (C++20)
    		eine view , die aus den Elementen eines range besteht, die ein Prädikat erfüllen
    (Klassentemplate) (Range-Adapterobjekt)
    (C++20)
    		eine view einer Sequenz, die eine Transformationsfunktion auf jedes Element anwendet
    (Klassentemplate) (Range-Adapterobjekt)
    (C++20)
    		eine view , die aus den Anfangselementen einer anderen view besteht, bis zum ersten Element, bei dem ein Prädikat false zurückgibt
    (Klassentemplate) (Range-Adapterobjekt)
    (C++20)
    		eine view , die aus den Elementen einer anderen view besteht und die anfängliche Teilsequenz von Elementen überspringt, bis zum ersten Element, bei dem das Prädikat false zurückgibt
    (Klassentemplate) (Range-Adapterobjekt)
    (C++23)
    		eine view , die aus Ergebnissen der Anwendung einer Transformationsfunktion auf entsprechende Elemente der angepassten Views besteht
    (Klassentemplate) (Anpassungspunktobjekt)
    (C++23)
    		eine view , die aus Ergebnissen der Anwendung einer Transformationsfunktion auf benachbarte Elemente des angepassten Views besteht
    (Klassentemplate) (Range-Adapterobjekt)