Namespaces
Variants

    std::vector<T,Allocator>::vector

    Von de.cppreference.net
     
    C++
     
    Containerbibliothek
     
    std::vector
    Membertypen
    Memberfunktionen
    Nicht-Memberfunktionen
    (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
    Ableitungsleitfäden(C++17)
     
    vector() : vector(Allocator()) {}
    		(1) (seit C++11)
    (bis C++17)    		 
    vector() noexcept(noexcept(Allocator())) : vector(Allocator()) {}
    		(seit C++17)
    (constexpr seit C++20)    		 
    explicit vector( const Allocator& alloc = Allocator() );
    		(2) (bis C++11) 
    explicit vector( const Allocator& alloc );
    		(seit C++11)
    (noexcept seit C++17)
    (constexpr seit C++20)    		 
    explicit vector( size_type count,
                 const Allocator& alloc = Allocator() );
    		(3) (seit C++11) 
    explicit vector( size_type count, const T& value = T(),
                 const Allocator& alloc = Allocator() );
    		(4) (bis C++11) 
    vector( size_type count, const T& value,
        const Allocator& alloc = Allocator() );
    		(seit C++11)
    (constexpr seit C++20)    		 
    template< class InputIt >
vector( InputIt first, InputIt last,
        const Allocator& alloc = Allocator() );
    		(5) (constexpr seit C++20) 
    template< container-compatible-range<T> R >
constexpr vector( std::from_range_t, R&& rg,
                  const Allocator& alloc = Allocator() );
    		(6) (seit C++23) 
    vector( const vector& other );
    		(7) (constexpr seit C++20) 
    vector( vector&& other );
    		(8) (seit C++11)
    (noexcept seit C++17)
    (constexpr seit C++20)    		 
    vector( const vector& other, const Allocator& alloc );
    		(9) (seit C++11)
    (constexpr seit C++20)
    (bis C++23)    		 
    constexpr vector( const vector& other,
                  const std::type_identity_t<Allocator>& alloc );
    		(seit C++23) 
    vector( vector&& other, const Allocator& alloc );
    		(10) (seit C++11)
    (constexpr seit C++20)
    (bis C++23)    		 
    constexpr vector( vector&& other,
                  const std::type_identity_t<Allocator>& alloc );
    		(seit C++23) 
    vector( std::initializer_list<T> init,
        const Allocator& alloc = Allocator() );
    		(11) (seit C++11)

    Konstruiert ein neues vector aus einer Vielzahl von Datenquellen, optional unter Verwendung eines vom Benutzer bereitgestellten Allokators alloc.

    1) Der Standardkonstruktor seit C++11. Konstruiert einen leeren vector mit einem default-konstruierten Allokator.
    Wenn Allocator nicht DefaultConstructible ist, ist das Verhalten undefiniert.
    2) Der Standardkonstruktor bis C++11. Konstruiert einen leeren vector mit dem gegebenen Allokator alloc.
    3) Konstruiert einen vector mit count default-eingefügten Objekten von T. Es werden keine Kopien erstellt.
    Wenn T nicht DefaultInsertable in std::vector<T> ist, ist das Verhalten undefiniert.
    4) Konstruiert einen vector mit count Kopien von Elementen mit Wert value.

    Wenn T nicht CopyInsertable in std::vector<T> ist, ist das Verhalten undefiniert.

    		(seit C++11)
    5) Konstruiert einen vector mit dem Inhalt des Bereichs [first, last). Jeder Iterator in [first, last) wird genau einmal dereferenziert.

    Wenn InputIt die Anforderungen von LegacyInputIterator nicht erfüllt, wird stattdessen die Überladung (4) mit den Argumenten static_cast<size_type>(first), last und alloc aufgerufen.

    		(bis C++11)

    Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.

    Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

    		(seit C++11)
    6) Konstruiert einen vector mit dem Inhalt des Bereichs rg. Jeder Iterator in rg wird genau einmal dereferenziert.
    Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
    7-10) Konstruiert einen vector mit dem Inhalt von other.
    7) Der Kopierkonstruktor.

    Der Allokator wird ermittelt, als ob std::allocator_traits<Allocator>::select_on_container_copy_construction(alloc) aufgerufen würde, wobei alloc der Allokator von other ist.

    		(seit C++11)
    8) Der Verschiebekonstruktor. Der Allokator wird durch Verschiebungskonstruktion von other.get_allocator() ermittelt.
    9) Gleich wie der Kopierkonstruktor, außer dass alloc als Allokator verwendet wird.
    Wenn T nicht CopyInsertable in std::vector<T> ist, ist das Verhalten undefiniert.
    10) Gleich wie der Verschiebekonstruktor, außer dass alloc als Allokator verwendet wird.
    Wenn T nicht MoveInsertable in std::vector<T> ist, ist das Verhalten undefiniert.
    11) Äquivalent zu vector(il.begin(), il.end(), alloc).

    Parameter

    alloc - Allokator, der für alle Speicherallokationen dieses Containers verwendet wird
    count - die Größe des Containers
    value - der Wert, mit dem Elemente des Containers initialisiert werden
    first, last - das Paar von Iteratoren, die den Bereich der Elemente definieren, aus dem die Elemente kopiert werden
    other - ein anderer Container, der als Quelle zur Initialisierung der Elemente des Containers verwendet wird
    init - Initialisierungsliste zur Initialisierung der Elemente des Containers
    rg - ein containerkompatibler Bereich

    Komplexität

    1,2) Konstant.
    3,4) Linear in count .
    5) Gegeben std:: distance ( first, last ) als N :
    • Der Kopierkonstruktor von T wird nur N -mal aufgerufen.
    • Keine Neuzuweisung erfolgt.
    • Andernfalls:
    • Der Kopierkonstruktor von T wird O(N) -mal aufgerufen.
    • Neuzuweisung erfolgt O(log N) -mal.
    6) Gegeben ranges:: distance ( rg ) als N :
    (bis C++26)
    • Wenn R eine der folgenden Bedingungen erfüllt:
    dann:
    		(seit C++26)
    • Initialisiert exakt N Elemente aus dem Ergebnis der Dereferenzierung aufeinanderfolgender Iteratoren von rg .
    • Keine Reallokation erfolgt.
    • Andernfalls:
    • Der Kopier- oder Move-Konstruktor von T wird O(N) Mal aufgerufen.
    • Reallokation erfolgt O(log N) Mal.
    7) Linear in other. size ( ) .
    8) Konstante.
    9) Linear in other. size ( ) .
    10) Linear in other. size ( ) if alloc ! = other. get_allocator ( ) , andernfalls konstant.
    11) Linear in init. size ( ) .

    Ausnahmen

    Aufrufe von Allocator :: allocate können eine Exception werfen.

    Anmerkungen

    Nach der Container-Verschiebungskonstruktion (Überladung (8)) bleiben Referenzen, Zeiger und Iteratoren, die ursprünglich auf Elemente in other verwiesen, gültig, verweisen aber auf Elemente, die sich jetzt in *this befinden. Der aktuelle Standard gibt diese Garantie durch die allgemeine Aussage in [container.reqmts]/67, und eine direktere Garantie wird via LWG issue 2321 in Betracht gezogen.

    Feature-Test-Makro Wert Std Feature
    __cpp_lib_containers_ranges 202202L (C++23) Ranges-bewusste Konstruktion und Einfügung; Überladung (6)

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <string>
#include <vector>
template<typename T>
std::ostream& operator<<(std::ostream& s, const std::vector<T>& v)
{
    s.put('{');
    for (char comma[]{'\0', ' ', '\0'}; const auto& e : v)
        s << comma << e, comma[0] = ',';
    return s << "}\n";
}
int main()
{
    // C++11 Initialisierungslisten-Syntax:
    std::vector<std::string> words1{"the", "frogurt", "is", "also", "cursed"};
    std::cout << "1: " << words1;
    // words2 == words1
    std::vector<std::string> words2(words1.begin(), words1.end());
    std::cout << "2: " << words2;
    // words3 == words1
    std::vector<std::string> words3(words1);
    std::cout << "3: " << words3;
    // words4 ist {"Mo", "Mo", "Mo", "Mo", "Mo"}
    std::vector<std::string> words4(5, "Mo");
    std::cout << "4: " << words4;
    const auto rg = {"cat", "cow", "crow"};
#ifdef __cpp_lib_containers_ranges
    std::vector<std::string> words5(std::from_range, rg); // Überladung (6)
#else
    std::vector<std::string> words5(rg.begin(), rg.end()); // Überladung (5)
#endif
    std::cout << "5: " << words5;
}

    Ausgabe: 

    1: {the, frogurt, is, also, cursed}
2: {the, frogurt, is, also, cursed}
3: {the, frogurt, is, also, cursed}
4: {Mo, Mo, Mo, Mo, Mo}
5: {cat, cow, crow}

    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 134 C++98 Überladung ( 5 ) erlaubte bis zu 2N  Kopierkonstruktoraufrufe im Input-Iterator-Fall geändert auf O(N) Aufrufe
    LWG 438 C++98 Überladung ( 5 ) würde nur Überladung ( 4 ) aufrufen
    wenn InputIt ein integraler Typ ist     		ruft Überladung ( 4 ) auf wenn InputIt
    kein LegacyInputIterator ist
    LWG 2193 C++11 der Standardkonstruktor war explicit auf non-explicit geändert
    LWG 2210 C++11 Überladung ( 3 ) hatte keinen Allokator-Parameter Parameter hinzugefügt
    N3346 C++11 für Überladung ( 3 ) , die Elemente im
    Container waren value-initialized     		sie sind default-inserted

    Siehe auch

    		weist dem Container Werte zu
    (öffentliche Elementfunktion)
    		weist dem Container Werte zu
    (öffentliche Elementfunktion)