Namespaces
Variants

    C++ named requirements: SequenceContainer

    From de.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.