Namespaces
Variants

C++ named requirements: SequenceContainer

From cppreference.net
C++
C++ named requirements

Ein SequenceContainer ist ein Container , der Objekte desselben Typs in einer linearen Anordnung speichert.

Inhaltsverzeichnis

Anforderungen

Gegeben die folgenden Typen und Werte:

Typ Definition
C eine Sequenz-Container-Klasse
T der Elementtyp von C
A der Allokator-Typ von C :
R (seit C++23) ein Typ, der container-compatible-range  <T> modelliert
Args (seit C++11) ein Template-Parameter-Pack
Iter C::iterator
Ref C::reference
CRef C::const_reference
Wert Definition
v ein Wert vom Typ C
cv ein Wert vom Typ const C
i , j LegacyInputIterator s , sodass [ i , j ) ein gültiger Bereich ist und die Iteratoren auf Elemente verweisen, die implizit in C::value_type konvertierbar sind
rg (seit C++23) ein Wert vom Typ R
il (seit C++11) ein Wert vom Typ std:: initializer_list < C :: value_type >
n ein Wert vom Typ C::size_type
p ein gültiger const-Iterator in v
q ein gültiger dereferenzierbarer const-Iterator in v
q1 , q2 const-Iteratoren in v , sodass [ q1 , q2 ) ein gültiger Bereich ist
t ein Wert (bis C++11) ein Lvalue oder const Rvalue (seit C++11) vom Typ C::value_type
rv (seit C++11) ein nicht-konstanter Rvalue vom Typ C::value_type
args (seit C++11) ein Funktionsparameter-Pack mit dem Muster Arg&&

C erfüllt die Anforderungen von SequenceContainer wenn alle folgenden Bedingungen erfüllt sind:

  • C erfüllt die Anforderungen eines Container .
  • Die folgenden Aussagen und Ausdrücke sind wohlgeformt und haben die spezifizierte Semantik:
Grundlegende Operationen
(erforderlich für alle Sequenzcontainer in der Standardbibliothek außer std::array (seit C++11) )
Statement Semantik [1]
C c ( n, t ) ; Effekt Konstruiert den Sequenz-Container mit n Kopien von t .
Vorbedingung

T ist CopyInsertable in C .

(seit C++11)
Postcondition std:: distance ( c. begin ( ) , c. end ( ) ) ist n .
C c ( i, j ) ; Effekt Konstruiert den Sequenzcontainer elementweise gleich dem Bereich [ i , j ) .
  • Jeder Iterator im Bereich [ i , j ) wird genau einmal dereferenziert.
Vorbedingung

T ist EmplaceConstructible in C aus * i .

(seit C++11)
Postcondition std:: distance ( c. begin ( ) , c. end ( ) ) ist std:: distance ( i, j ) .
Expression Type Semantics
C ( std:: from_range , rg )
(seit C++23) 		C Effekt Konstruiert den Sequenzcontainer elementweise gleich dem Bereich rg .
  • Jeder Iterator im Bereich rg wird genau einmal dereferenziert.
Vorbedingung T ist EmplaceConstructible in X aus * ranges:: begin ( rg ) .
Postcondition std:: distance ( begin ( ) , end ( ) ) ist ranges:: distance ( rg ) .
C ( il )
(seit C++11) 		C Entspricht C ( il. begin ( ) , il. end ( ) ) .
v = il
(seit C++11) 		C& Effekt Weist den durch il repräsentierten Bereich v zu. [2]
Rückgabewert * this
Vorbedingung T ist CopyInsertable in C und CopyAssignable .
Postcondition Bestehende Elemente von v werden entweder zerstört oder zugewiesen.
v. emplace ( p, args )
(seit C++11) 		Iter Effekt Fügt ein Objekt vom Typ T ein, konstruiert mit std:: forward < Args > ( args ) ... vor p .
Rückgabewert Ein Iterator, der auf das neue Element zeigt, das aus args in v konstruiert wurde.
Vorbedingung T ist EmplaceConstructible in C aus args .
v. insert ( p, t ) Iter Effekt Fügt eine Kopie von t vor p ein.
Rückgabewert Ein Iterator, der auf die Kopie von t zeigt, die in v eingefügt wurde.
Vorbedingung

T ist CopyInsertable in C .

(since C++11)
v. insert ( p, rv )
(seit C++11) 		Iter Effekt Fügt eine Kopie von rv vor p ein, möglicherweise unter Verwendung von Move-Semantik.
Rückgabewert Ein Iterator, der auf die Kopie von rv zeigt, die in v eingefügt wurde.
Vorbedingung T ist MoveInsertable in C .
v. insert ( p, n, t ) Iter Effekt Fügt n Kopien von t vor p ein.
Rückgabewert Ein Iterator, der auf die Kopie des ersten in v eingefügten Elements zeigt, oder p falls n gleich ​ 0 ​ ist.
Vorbedingung

T ist CopyInsertable in C und CopyAssignable .

(seit C++11)
v. insert ( p, i, j ) Iter Effekt Fügt Kopien der Elemente im Bereich [ i , j ) vor p ein.
  • Jeder Iterator im Bereich [ i , j ) wird genau einmal dereferenziert.
Rückgabewert Ein Iterator, der auf die Kopie des ersten in v eingefügten Elements zeigt, oder p falls i == j true ist.
Vorbedingung
(seit C++11)
  • i und j sind nicht in v .
v. insert_range ( p, rg )
(seit C++23) 		Iter Effekt Fügt Kopien der Elemente aus rg vor p ein.
  • Jeder Iterator im Bereich rg wird genau einmal dereferenziert.
Rückgabewert Ein Iterator, der auf die Kopie des ersten in v eingefügten Elements zeigt, oder p falls rg leer ist.
Vorbedingung
v. insert ( p, il )
(seit C++11) 		Iter Entspricht v. insert ( p, il. begin ( ) , il. end ( ) ) .
v. erase ( q ) Iter Effekt Löscht das Element, auf das q zeigt.
Rückgabewert Ein Iterator, der auf das Element unmittelbar nach q vor dem Löschen des Elements zeigt, oder v. end ( ) falls kein solches Element existiert.
v. erase ( q1, q2 ) Iter Effekt Löscht Elemente im Bereich [ q1 , q2 ) .
Rückgabewert Ein Iterator, der auf das Element zeigt, auf das zuvor q2 gezeigt hat, bevor Elemente gelöscht wurden, oder v. end ( ) falls kein solches Element existiert.
v. clear ( ) void Effekt Zerstört alle Elemente in v .
  • Macht alle Referenzen, Zeiger und Iteratoren ungültig, die auf die Elemente von v verweisen, und kann den Past-the-End-Iterator ungültig machen.
Postcondition v. empty ( ) ist true .
Komplexität Linear.
v. assign ( i, j ) void Effekt Ersetzt Elemente in v durch eine Kopie von [ i , j ) .
  • Macht alle Referenzen, Zeiger und Iteratoren ungültig, die auf die Elemente von v verweisen.
  • Jeder Iterator in [ i , j ) wird genau einmal dereferenziert.
Vorbedingung
(seit C++11)
  • i und j sind nicht in v .
v. assign_range ( rg )
(seit C++23) 		void Effekt Ersetzt Elemente in v mit einer Kopie jedes Elements in rg .
  • Wenn std:: assignable_from
    < T & , ranges:: range_reference_t < R >>     nicht modelliert wird, ist das Programm fehlerhaft.
  • Macht alle Referenzen, Zeiger und Iteratoren ungültig, die auf die Elemente von v verweisen.
  • Jeder Iterator im Bereich rg wird genau einmal dereferenziert.
Vorbedingung
v. assign ( il )
(seit C++11) 		void Entspricht v. assign ( il. begin ( ) , il. end ( ) ) .
v. assign ( n, t ) void Effekt Ersetzt Elemente in v durch n Kopien von t .
Vorbedingung

T ist CopyInsertable in C und CopyAssignable .

(seit C++11)
Zusätzliche Operationen [3]
(nur für spezifizierte Sequenzcontainer erforderlich, Auslassung von std:: )
Expression Type Semantics
v. front ( ) Ref Container basic_string , array , vector , inplace_vector , deque , list , forward_list
Rückgabewert * v. begin ( )
cv. front ( ) CRef Container basic_string , array , vector , inplace_vector , deque , list , forward_list
Rückgabewert * cv. begin ( )
v. back ( ) Ref Container basic_string , array , vector , inplace_vector , deque , list
Entspricht auto tmp = v. end ( ) ; -- tmp ; return * tmp ; [4] .
cv. back ( ) CRef Container basic_string , array , vector , inplace_vector , deque , list
Entspricht auto tmp = cv. end ( ) ; -- tmp ; return * tmp ; [5] .
v. emplace_front ( args )
(seit C++11) 		void Container deque , list , forward_list
Effekt Fügt ein Objekt vom Typ T voran, das mit std:: forward < Args > ( args ) ... konstruiert wurde.
Rückgabewert v. front ( )
Vorbedingung T ist EmplaceConstructible in C aus args .
v. emplace_back ( args )
(seit C++11) 		void Container vector , inplace_vector , deque , list
Effekt Fügt ein Objekt vom Typ T hinzu, das mit std:: forward < Args > ( args ) ... konstruiert wurde.
Rückgabewert v. back ( )
Vorbedingung T ist EmplaceConstructible in C aus args .
v. push_front ( t ) void Container deque , list , forward_list
Effekt Fügt eine Kopie von t voran.
Vorbedingung

T ist CopyInsertable in C .

(seit C++11)
v. push_front ( rv )
(seit C++11) 		void Container deque , list , forward_list
Effekt Fügt eine Kopie von rv voran, möglicherweise unter Verwendung von Move-Semantik.
Vorbedingung T ist MoveInsertable in C .
v. prepend_range ( rg )
(seit C++23) 		void Container deque , list , forward_list
Effekt Fügt [6] Kopien von Elementen in rg vor v. begin ( ) ein.
  • Jeder Iterator im Bereich rg wird genau einmal dereferenziert.
Vorbedingung T ist EmplaceConstructible in C von * ranges:: begin ( rg ) .
v. push_back ( t ) void Container basic_string , vector , inplace_vector , deque , list
Effekt Hängt eine Kopie von t an.
Vorbedingung

T ist CopyInsertable in C .

(since C++11)
v. push_back ( rv )
(seit C++11) 		void Container basic_string , vector , inplace_vector , deque , list
Effekt Hängt eine Kopie von rv an, möglicherweise unter Verwendung von Move-Semantik.
Vorbedingung T ist MoveInsertable in C .
v. append_range ( rg )
(seit C++23) 		void Container vector , inplace_vector , deque , list
Effekt Fügt [6] Kopien von Elementen in rg vor v. end ( ) ein.
  • Jeder Iterator im Bereich rg wird genau einmal dereferenziert.
Vorbedingung T ist EmplaceConstructible in C aus * ranges:: begin ( rg ) .
v. pop_front ( ) void Container deque , list , forward_list
Effekt Zerstört das erste Element.
Vorbedingung a. empty ( ) ist false .
v. pop_back ( ) void Container basic_string , vector , inplace_vector , deque , list
Effekt Zerstört das letzte Element.
Vorbedingung a. empty ( ) ist false .
v [ n ] Ref Container basic_string , array , vector , inplace_vector , deque
Entspricht return * ( v. begin ( ) + n ) ; .
cv [ n ] CRef Container basic_string , array , vector , inplace_vector , deque
Entspricht return * ( cv. begin ( ) + n ) ; .
v. at ( n ) Ref Container basic_string , array , vector , inplace_vector , deque
Rückgabewert * ( v. begin ( ) + n )
Exceptions Wirft std::out_of_range falls n >= v. size ( ) true ist.
cv. at ( n ) CRef Container basic_string , array , vector , inplace_vector , deque
Rückgabewert * ( cv. begin ( ) + n )
Exceptions Wirft std::out_of_range wenn n >= cv. size ( ) true ist.
Hinweise
  1. ↑ Für einen Ausdruck, dessen Wirkung bestimmten anderen Operationen entspricht, werden die Bedingungen der Ausdrücke innerhalb dieser Operationen zusätzlich zu den in der Tabelle aufgeführten Bedingungen übernommen.
  2. ↑ std::array unterstützt Zuweisung von einer geschweiften Klammer-Initialisierungsliste , jedoch nicht von einem std::initializer_list .
  3. ↑ Alle nachfolgenden Operationen außer prepend_range und append_range (seit C++23) benötigen amortisiert konstante Zeit.
  4. ↑ In C++98 wurde tmp mit dem Typ C::iterator deklariert.
  5. ↑ In C++98 wurde tmp mit dem Typ C::const_iterator deklariert.
  6. ↑ 6.0 6.1 Die Einfügereihenfolge relativ zur Reihenfolge der Elemente in rg ist nicht umkehrend.

Zusätzlich, für jeden Sequenzcontainer:

  • Ein Konstruktor-Template, das zwei Input-Iteratoren akzeptiert, und die Member-Funktions-Template-Überladungen von insert , append , assign , replace , die zwei Input-Iteratoren akzeptieren, nehmen nicht an der Überladungsauflösung teil, wenn das entsprechende Template-Argument nicht LegacyInputIterator erfüllt.
  • Ein Deduction Guide, der entweder einen LegacyInputIterator oder einen Allocator Template-Parameter besitzt, nimmt nicht an der Überladungsauflösung teil, wenn für diesen Parameter ein Typ abgeleitet wird, der nicht als Input Iterator bzw. Allocator qualifiziert ist.
(seit C++17)

Standardbibliothek

Die folgenden Standardbibliothek-String-Typen und Container erfüllen die SequenceContainer -Anforderungen:

speichert und manipuliert Zeichenfolgen
(Klassentemplate)
(C++11)
festgroße Inplace-kontinuierliche Array
(Klassentemplate)
veränderbare kontinuierliche Array
(Klassentemplate)
(C++26)
veränderbare, feste Kapazität, Inplace-kontinuierliche Array
(Klassentemplate)
doppelseitige Warteschlange
(Klassentemplate)
(C++11)
einfach verkettete Liste
(Klassentemplate)
doppelt verkettete Liste
(Klassentemplate)

Verwendungshinweise

Container Vorteile Nachteile
std::vector Schneller Zugriff, zusammenhängende Speicherung Größtenteils ineffiziente Einfügungen/Löschungen
std:: inplace_vector Schneller Zugriff, Inplace-zusammenhängende Speicherung Feste Kapazität und größtenteils ineffiziente Einfügungen/Löschungen
std::array Schneller Zugriff, Inplace-zusammenhängende Speicherung Feste Elementanzahl und keine Einfügung/Löschung
std::deque Schneller Zugriff, effiziente Einfügung/Löschung am Anfang/Ende Ineffiziente Einfügung/Löschung in der Mitte der Sequenz
std::list
std::forward_list 		Effiziente Einfügung/Löschung in der Mitte der Sequenz Zugriff ist größtenteils linear in der Zeit

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 139 C++98 die optionalen Operationen waren nicht erforderlich
für die bezeichneten Container implementiert zu werden 		mit amortisierter Zeit erforderlich
LWG 149 C++98 v. insert ( p, t ) gab Iter zurück, während
v. insert ( p, n, t ) und v. insert ( p, n, t )
void zurückgaben 		alle geben Iter zurück
LWG 151 C++98 q1 musste dereferenzierbar sein [1] kann nicht-dereferenzierbar sein
LWG 355 C++98 Aufruf von v. back ( ) oder v. pop_back ( ) würde
-- v. end ( ) ausführen, was gefährlich ist [2] 		dekrementiert eine Kopie
von v. end ( ) stattdessen
LWG 589 C++98 die Elemente, auf die i und j verweisen,
könnten nicht konvertierbar zu C::value_type sein 		sie sind implizit
konvertierbar zu C::value_type
LWG 2194 C++11 std::queue , std::priority_queue und
std::stack waren ebenfalls SequenceContainer s [3] 		sie sind keine SequenceContainer s
LWG 2231 C++11 die Komplexitätsanforderung von v. clear ( )
wurde in C++11 fälschlicherweise ausgelassen 		Komplexität als linear bestätigt
LWG 3927 C++98 operator [ ] hatte keine implizite Anforderung implizite Anforderung hinzugefügt
  1. ↑ Es handelt sich um einen Defekt, weil das Verhalten von v. erase ( v. begin ( ) , v. end ( ) ) undefiniert ist, falls v ein leerer Container ist.
  2. ↑ Falls der Typ von v. end ( ) ein fundamentaler Typ ist, ist -- v. end ( ) fehlerhaft. Es ist gefährlich, wenn der Typ von v templatisiert ist, da dieser Fehler in diesem Fall schwer zu finden sein kann.
  3. ↑ Sie wurden in C++98 nicht als SequenceContainer s dokumentiert.