std::inplace_vector<T,N>::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::inplace_vector

Membertypen
Memberfunktionen
inplace_vector::inplace_vector inplace_vector::~inplace_vector    inplace_vector::operator= inplace_vector::assign inplace_vector::assign_range Größe und Kapazität inplace_vector::empty inplace_vector::size inplace_vector::max_size inplace_vector::capacity inplace_vector::resize inplace_vector::reserve inplace_vector::shrink_to_fit Iteratoren inplace_vector::begininplace_vector::cbegin inplace_vector::endinplace_vector::cend inplace_vector::rbegininplace_vector::crbegin inplace_vector::rendinplace_vector::crend	Elementzugriff inplace_vector::at inplace_vector::operator[] inplace_vector::front inplace_vector::back inplace_vector::data Modifizierer inplace_vector::clear inplace_vector::erase inplace_vector::swap inplace_vector::insert inplace_vector::insert_range inplace_vector::emplace inplace_vector::emplace_back inplace_vector::try_emplace_back inplace_vector::unchecked_emplace_back inplace_vector::push_back inplace_vector::try_push_back inplace_vector::unchecked_push_back inplace_vector::pop_back inplace_vector::append_range inplace_vector::try_append_range
Nicht-Member-Funktionen
erase(std::inplace_vector)erase_if(std::inplace_vector) swap(std::inplace_vector)	operator==operator<=>

 

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

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 nimmt nur an der Überladungsauswahl teil, wenn InputIt ein LegacyInputIterator ist (um Mehrdeutigkeiten mit der Überladung (3) zu vermeiden).

Jede Iterator in [first, last) wird einmal dereferenziert.

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

5) Fügt Elemente aus der Initialisierungsliste ilist vor pos ein. Äquivalent zu: insert(pos, ilist.begin(), ilist.end());.

Parameter

pos	-	Iterator, vor dem der Inhalt eingefügt wird (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 Quell- Bereich der einzufügenden Elemente definiert
ilist	-	std::initializer_list, aus dem die Werte eingefügt werden sollen
Typanforderungen
- T muss die Anforderungen von CopyInsertable erfüllen, um Überladung (1) zu verwenden.
- T muss die Anforderungen von 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.

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

Linear in der Anzahl der eingefügten Elemente plus der Distanz zwischen pos und end() des Containers.

Ausnahmen

• Wirft std::bad_alloc, wenn vor dem Aufruf size() == capacity() ist. Die Funktion hat keine Effekte (starke Ausnahmensicherheitsgarantie).
• Jede Ausnahme, die bei der Initialisierung des eingefügten Elements oder durch eine LegacyInputIterator-Operation geworfen wird. Elemente in [​0​, pos) werden nicht modifiziert.

Beispiel

Führen Sie diesen Code aus

#include <initializer_list>
#include <inplace_vector>
#include <iterator>
#include <new>
#include <print>
 
int main()
{
    std::inplace_vector<int, 14> v(3, 100);
    std::println("1. {}", v);
 
    auto pos = v.begin();
    pos = v.insert(pos, 200); // overload (1)
    std::println("2. {}", v);
 
    v.insert(pos, 2, 300); // overload (3)
    std::println("3. {}", v);
 
    int arr[] = {501, 502, 503};
    v.insert(v.begin(), arr, arr + std::size(arr)); // overload (4)
    std::println("4. {}", v);
 
    v.insert(v.end(), {601, 602, 603}); // overload (5)
    std::println("5. {}", v);
 
    const auto list = {-13, -12, -11};
    try
    {
        v.insert(v.begin(), list); // throws: no space
    }
    catch(const std::bad_alloc&)
    {
        std::println("bad_alloc: v.capacity()={} < v.size()={} + list.size()={}",
                     v.capacity(), v.size(), list.size());
    }
}

Ausgabe

1. [100, 100, 100]
2. [200, 100, 100, 100]
3. [300, 300, 200, 100, 100, 100]
4. [501, 502, 503, 300, 300, 200, 100, 100, 100]
5. [501, 502, 503, 300, 300, 200, 100, 100, 100, 601, 602, 603]
bad_alloc: v.capacity()=14 < v.size()=12 + list.size()=3

Siehe auch

emplace	konstruiert Elemente direkt (in-place) (public member function)
insert_range	fügt einen Bereich von Elementen ein (public member function)