Namespaces
Variants

Assignable wrapper (C++20)

From cppreference.net
C++
Ranges library
Range adaptors
Helper items
copyable-box
movable-box
(until C++23) (C++23)


template < class T >

requires std:: copy_constructible < T > && std:: is_object_v < T >

class /*copyable-box*/ ;
(seit C++20)
(bis C++23)
( nur zur Darstellung* )
template < class T >

requires std:: move_constructible < T > && std:: is_object_v < T >

class /*movable-box*/ ;
(seit C++23)
( nur zur Darstellung* )

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

Der Wrapper verhält sich genau wie std:: optional < T > , mit der Ausnahme, dass der Standardkonstruktor, der Kopierzuweisungsoperator und der Verschiebezuweisungsoperator (bedingt) anders sind als die von std::optional , was T bei Bedarf mit Zuweisbarkeit erweitert und es immer copyable oder movable (seit C++23) erfüllen lässt.

Falls 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 stets einen Wert enthält.

(bis C++23)

Falls T

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

(seit C++23)

Inhaltsverzeichnis

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)