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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::vector

Membertypen
Memberfunktionen
vector::vector vector::~vector vector::operator= vector::assign vector::assign_range (C++23)   vector::get_allocator Elementzugriff vector::operator[] vector::at vector::data vector::front vector::back Iteratoren vector::beginvector::cbegin (C++11) vector::endvector::cend (C++11) vector::rbeginvector::crbegin (C++11) vector::rendvector::crend (C++11)	Kapazität vector::empty vector::size vector::max_size vector::reserve vector::capacity vector::shrink_to_fit (DR*) Modifizierer vector::clear vector::erase vector::insert vector::insert_range (C++23) vector::append_range (C++23) vector::emplace (C++11) vector::emplace_back (C++11) vector::push_back vector::pop_back vector::resize vector::swap
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::vector) erase(std::vector)erase_if(std::vector) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides(C++17)

 

iterator insert( const_iterator pos, const T& value );	(1)	(constexpr seit C++20)
iterator insert( const_iterator pos, T&& value );	(2)	(seit C++11) (constexpr seit C++20)
iterator insert( const_iterator pos,                  size_type count, const T& value );	(3)	(constexpr seit C++20)
template< class InputIt > iterator insert( const_iterator pos, InputIt first, InputIt last );	(4)	(constexpr seit C++20)
iterator insert( const_iterator pos, std::initializer_list<T> ilist );	(5)	(seit C++11) (constexpr seit C++20)

Fügt Elemente an der angegebenen Position in den Container ein.

1) Fügt eine Kopie von value vor pos ein.

2) Fügt value vor pos ein, möglicherweise unter Verwendung von Move-Semantik.

3) Fügt count Kopien von value vor pos ein.

4) Fügt Elemente aus dem Bereich [first, last) vor pos ein.

Diese Überladung hat denselben Effekt wie Überladung (3), wenn InputIt ein integraler Typ ist.	(bis C++11)
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt LegacyInputIterator erfüllt, um Mehrdeutigkeiten mit Überladung (3) zu vermeiden.	(seit C++11)

Wenn first und last Iteratoren in *this sind, ist das Verhalten undefiniert.

5) Fügt Elemente aus der Initialisierungsliste ilist vor pos ein.

Wenn nach der Operation die neue size() größer ist als die alte capacity(), findet eine Reallokation statt, in diesem Fall werden alle Iteratoren (einschließlich des end() Iterators) und alle Referenzen auf die Elemente ungültig. Andernfalls bleiben nur die Iteratoren und Referenzen vor dem Einfügepunkt gültig.

Parameter

pos	-	Iterator, vor dem der Inhalt eingefügt werden soll (pos kann der end() Iterator sein)
value	-	Elementwert, der eingefügt werden soll
zählt	-	Anzahl der einzufügenden Elemente
first, last	-	Das Iteratorenpaar, das den einzufügenden Elementbereich definiert (cannot be iterators into container for which insert is called)
ilist	-	std::initializer_list, aus dem die Werte eingefügt werden sollen
Typanforderungen
- T muss die Anforderungen von CopyAssignable und CopyInsertable erfüllen, um Überladung (1) zu verwenden.
- T muss die Anforderungen von MoveAssignable und MoveInsertable erfüllen, um Überladung (2) zu verwenden.
- T muss die Anforderungen von CopyAssignable und CopyInsertable erfüllen, um Überladung (3) zu verwenden.
- T muss die Anforderungen von EmplaceConstructible erfüllen, um die Überladungen (4,5) zu verwenden.
- T muss die Anforderungen von MoveAssignable und MoveInsertable erfüllen, um Überladung (4) zu verwenden. Erforderlich nur, wenn InputIt LegacyInputIterator erfüllt, aber nicht LegacyForwardIterator. (bis C++17)
- T muss die Anforderungen von Swappable, MoveAssignable, MoveConstructible und MoveInsertable erfüllen, um die Überladungen (4,5) zu verwenden. (seit C++17)

Rückgabewert

1,2) Iterator, der auf den eingefügten value zeigt.

3) Iterator, der auf das erste eingefügte Element zeigt, oder pos, wenn count == 0.

4) Iterator, der auf das erste eingefügte Element zeigt, oder pos, wenn first == last.

5) Iterator, der auf das erste eingefügte Element zeigt, oder pos, wenn ilist leer ist.

Komplexität

1,2) Konstant plus linear zur Entfernung zwischen pos und dem Ende des Containers.

3) Linear zu count plus linear zur Entfernung zwischen pos und dem Ende des Containers.

4) Linear zu std::distance(first, last) plus linear zur Entfernung zwischen pos und dem Ende des Containers.

5) Linear zu ilist.size() plus linear zur Entfernung zwischen pos und dem Ende des Containers.

Ausnahmen

Wenn eine andere Ausnahme als durch

• den Kopierkonstruktor von T,

den Move-Konstruktor von T,

(seit C++11)

• den Kopierzuweisungsoperator von T,

den Move-Zuweisungsoperator von T,

(seit C++11)

• eine beliebige InputIt Operation,

geworfen wird, haben diese Funktionen keine Auswirkungen (starkes Ausnahme-Sicherheitsgarantie).

Wenn beim Einfügen eines einzelnen Elements am Ende eine Ausnahme geworfen wird und T CopyInsertable in *this ist oder std::is_nothrow_move_constructible<T>::value true ist, hat diese Funktion keine Auswirkungen (starke Ausnahme-Garantie). Andernfalls, wenn der Move-Konstruktor eines nicht-CopyInsertable T eine Ausnahme wirft, sind die Auswirkungen undefiniert.

(seit C++11)

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <iterator>
#include <string_view>
#include <vector>
 
namespace stq {
void println(std::string_view rem, const std::vector<int>& container)
{
    std::cout << rem.substr(0, rem.size() - 2) << '[';
    bool first{true};
    for (const int x : container)
        std::cout << (first ? first = false, "" : ", ") << x;
    std::cout << "]\n";
}
}
 
int main()
{
    std::vector<int> c1(3, 100);
    stq::println("1. {}", c1);
 
    auto pos = c1.begin();
    pos = c1.insert(pos, 200); // overload (1)
    stq::println("2. {}", c1);
 
    c1.insert(pos, 2, 300); // overload (3)
    stq::println("3. {}", c1);
 
    // pos no longer valid, get a new one:
    pos = c1.begin();
 
    std::vector<int> c2(2, 400);
    c1.insert(std::next(pos, 2), c2.begin(), c2.end()); // overload (4)
    stq::println("4. {}", c1);
 
    int arr[] = {501, 502, 503};
    c1.insert(c1.begin(), arr, arr + std::size(arr)); // overload (4)
    stq::println("5. {}", c1);
 
    c1.insert(c1.end(), {601, 602, 603}); // overload (5)
    stq::println("6. {}", c1);
}

Ausgabe

1. [100, 100, 100]
2. [200, 100, 100, 100]
3. [300, 300, 200, 100, 100, 100]
4. [300, 300, 400, 400, 200, 100, 100, 100]
5. [501, 502, 503, 300, 300, 400, 400, 200, 100, 100, 100]
6. [501, 502, 503, 300, 300, 400, 400, 200, 100, 100, 100, 601, 602, 603]

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 149	C++98	Überladungen (3) und (4) gaben nichts zurück	Gibt einen Iterator zurück.
LWG 247	C++98	Die Komplexität wurde nur für Überladung (3) angegeben	Für alle Überladungen angegeben
LWG 406	C++98	Die starke Ausnahme-Garantie galt auch, wenn die Ausnahme von einer InputIt Operation geworfen wurde	Keine Garantie in diesem Fall

Siehe auch

emplace (C++11)	konstruiert Elemente direkt (in-place) (public member function)
push_back	fügt ein Element am Ende hinzu (public member function)
inserter	erstellt einen std::insert_iterator vom Typ, der aus dem Argument abgeleitet wird (Funktionsvorlage)