Namespaces
Variants

std::inplace_vector<T,N>:: operator=

From cppreference.net
C++
Containers library
std::inplace_vector
Member types
Member functions
Non-member functions
constexpr inplace_vector & operator = ( const inplace_vector & other ) ;
(1) (seit C++26)
constexpr inplace_vector & operator = ( inplace_vector && other )
noexcept ( /* siehe unten */ ) ;
(2) (seit C++26)
constexpr inplace_vector & operator = ( std:: initializer_list < T > init ) ;
(3) (seit C++26)

Ersetzt den Inhalt des inplace_vector .

1) Copy assignment operator . Auch ein trivial copy assignment operator , falls std:: inplace_vector < T, N > einen trivial destructor besitzt, und std:: is_trivially_copy_constructible_v < T > && std:: is_trivially_copy_assignable_v < T > gleich true ist. Ersetzt den Inhalt durch eine Kopie des Inhalts von other .
2) Move-Zuweisungsoperator . Auch ein trivialer Move-Zuweisungsoperator , falls std:: inplace_vector < T, N > einen trivialen Destruktor besitzt und std:: is_trivially_move_constructible_v < T > && std:: is_trivially_move_assignable_v < T > den Wert true hat. Ersetzt den Inhalt durch den von other mittels Move-Semantik (d.h. die Daten in other werden von other in diesen Container verschoben). other befindet sich anschließend in einem gültigen aber unspezifizierten Zustand.
3) Ersetzt den Inhalt durch den durch die Initialisierungsliste init identifizierten Inhalt.

Inhaltsverzeichnis

Parameter

other - ein weiterer inplace_vector , der als Quelle zur Initialisierung der Elemente des Containers verwendet werden soll
init - Initialisierungsliste zur Initialisierung der Elemente des Containers

Komplexität

1,2) Linear in der Größe von * this und other .
3) Linear in der Größe von * this und init .

Ausnahmen

2)
noexcept Spezifikation:
noexcept ( N == 0 ||

( std:: is_nothrow_move_assignable_v < T > &&

std:: is_nothrow_move_constructible_v < T > ) )
3) Wirft std::bad_alloc falls init. size ( ) > N .

Beispiel

Diesen Code ausführen 
#include <initializer_list>
#include <inplace_vector>
#include <new>
#include <print>
#include <ranges>
#include <string>
int main()
{
    std::inplace_vector<int, 4> x({1, 2, 3}), y;
    std::println("Anfangs:");
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::println("Kopierzuweisung kopiert Daten von x nach y:");
    y = x; // overload (1)
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::inplace_vector<std::string, 3> z, w{"\N{CAT}", "\N{GREEN HEART}"};
    std::println("Anfangs:");
    std::println("z = {}", z);
    std::println("w = {}", w);
    std::println("Move-Zuweisung verschiebt Daten von w nach z:");
    z = std::move(w); // overload (2)
    std::println("z = {}", z);
    std::println("w = {}", w); // w is in valid but unspecified state
    auto l = {4, 5, 6, 7};
    std::println("Zuweisung von initializer_list {} an x:", l);
    x = l; // overload (3)
    std::println("x = {}", x);
    std::println("Zuweisung einer initializer_list mit Größe größer als N wirft eine Ausnahme:");
    try
    {
        x = {1, 2, 3, 4, 5}; // throws: (initializer list size == 5) > (capacity N == 4)
    }
    catch(const std::bad_alloc& ex)
    {
        std::println("ex.what(): {}", ex.what());
    }
}

Mögliche Ausgabe: 

Anfangs:
x = [1, 2, 3]
y = []
Kopierzuweisung kopiert Daten von x nach y:
x = [1, 2, 3]
y = [1, 2, 3]
Anfangs:
z = []
w = ["🐈", "💚"]
Move-Zuweisung verschiebt Daten von w nach z:
z = ["🐈", "💚"]
w = ["", ""]
Zuweisung von initializer_list [4, 5, 6, 7] an x:
x = [4, 5, 6, 7]
Zuweisung einer initializer_list mit Größe größer als N wirft eine Ausnahme:
ex.what(): std::bad_alloc

Siehe auch

konstruiert den inplace_vector
(öffentliche Elementfunktion)
weist dem Container Werte zu
(öffentliche Elementfunktion)