std::inplace_vector<T,N>::assign

 

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 void assign( size_type count, const T& value );	(1)	(seit C++26)
template< class InputIt > constexpr void assign( InputIt first, InputIt last );	(2)	(seit C++26)
constexpr void assign( std::initializer_list<T> ilist );	(3)	(seit C++26)

Ersetzt den Inhalt des Containers.

1) Ersetzt den Inhalt durch count Kopien von value value.

2) Ersetzt den Inhalt durch Kopien der Elemente im Bereich [first, last).

Wenn eines der Argumente ein Iterator in *this ist, ist das Verhalten undefiniert. Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn InputIt LegacyInputIterator erfüllt.

3) Ersetzt den Inhalt durch die Elemente aus ilist.

Parameter

zählt	-	die neue Größe des Containers
value	-	der Wert, mit dem die Elemente des Containers initialisiert werden sollen
first, last	-	das Iteratorpaar, das den Quell-Bereich der zu kopierenden Elemente definiert
ilist	-	std::initializer_list, aus dem die Werte kopiert werden sollen

Komplexität

1) Linear in count.

2) Linear in der Distanz zwischen first und last.

3) Linear in ilist.size().

Ausnahmen

1) std::bad_alloc, wenn count > capacity().

2) std::bad_alloc, wenn std::ranges::distance(first, last) > capacity).

3) std::bad_alloc, wenn ilist.size() > capacity).

1-3) Jede Ausnahme, die bei der Initialisierung von eingefügten Elementen ausgelöst wird.

Beispiel

Der folgende Code verwendet assign, um mehrere Zeichen zu einem std::inplace_vector<char, 5> hinzuzufügen

Führen Sie diesen Code aus

#include <inplace_vector>
#include <iterator>
#include <new>
#include <print>
 
int main()
{
    std::inplace_vector<char, 5> chars;
 
    chars.assign(4, 'a'); // overload (1)
    std::println("{}", chars);
 
    const char extra[3]{'a', 'b', 'c'};
    chars.assign(std::cbegin(extra), std::cend(extra)); // overload (2)
    std::println("{}", chars);
 
    chars.assign({'C', '+', '+', '2', '6'}); // overload (3)
    std::println("{}", chars);
 
    try
    {
        chars.assign(8, 'x'); // throws: count > chars.capacity()
    }
    catch(const std::bad_alloc&) { std::println("std::bad_alloc #1"); }
 
    try
    {
        const char bad[8]{'?'}; // ranges::distance(bad) > chars.capacity()
        chars.assign(std::cbegin(bad), std::cend(bad)); // throws
    }
    catch(const std::bad_alloc&) { std::println("std::bad_alloc #2"); }
 
    try
    {
        const auto l = {'1', '2', '3', '4', '5', '6'};
        chars.assign(l); // throws: l.size() > chars.capacity()
    }
    catch(const std::bad_alloc&) { std::println("std::bad_alloc #3"); }
}

Ausgabe

['a', 'a', 'a', 'a']
['a', 'b', 'c']
['C', '+', '+', '2', '6']
std::bad_alloc #1
std::bad_alloc #2
std::bad_alloc #3

Siehe auch

assign_range	weist dem Container einen Bereich von Werten zu (public member function)
operator=	weist dem Container Werte zu (public member function)