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) (depuis C++26)
constexpr inplace_vector & operator = ( inplace_vector && other )
noexcept ( /* voir ci-dessous */ ) ;
(2) (depuis C++26)
constexpr inplace_vector & operator = ( std:: initializer_list < T > init ) ;
(3) (depuis C++26)

Remplace le contenu du inplace_vector .

1) Opérateur d'assignation de copie . Également un opérateur d'assignation de copie trivial , si std:: inplace_vector < T, N > a un destructeur trivial , et std:: is_trivially_copy_constructible_v < T > && std:: is_trivially_copy_assignable_v < T > est true . Remplace le contenu par une copie du contenu de other .
2) Opérateur d'affectation par déplacement . Également un opérateur d'affectation par déplacement trivial , si std:: inplace_vector < T, N > possède un destructeur trivial , et std:: is_trivially_move_constructible_v < T > && std:: is_trivially_move_assignable_v < T > est true . Remplace le contenu par celui de other en utilisant la sémantique de déplacement (c'est-à-dire que les données de other sont déplacées de other vers ce conteneur). other se trouve ensuite dans un état valide mais non spécifié.
3) Remplace le contenu par celui identifié par la liste d'initialisation init .

Table des matières

Paramètres

other - un autre inplace_vector à utiliser comme source pour initialiser les éléments du conteneur
init - liste d'initialisation pour initialiser les éléments du conteneur

Complexité

1,2) Linéaire en fonction de la taille de * this et other .
3) Linéaire dans la taille de * this et init .

Exceptions

2)
noexcept spécification :
noexcept ( N == 0 ||

( std:: is_nothrow_move_assignable_v < T > &&

std:: is_nothrow_move_constructible_v < T > ) )
3) Lance std::bad_alloc si init. size ( ) > N .

Exemple

Exécuter ce code 
#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("Initialement :");
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::println("L'assignation par copie copie les données de x vers y :");
    y = x; // surcharge (1)
    std::println("x = {}", x);
    std::println("y = {}", y);
    std::inplace_vector<std::string, 3> z, w{"\N{CAT}", "\N{GREEN HEART}"};
    std::println("Initialement :");
    std::println("z = {}", z);
    std::println("w = {}", w);
    std::println("L'assignation par déplacement déplace les données de w vers z :");
    z = std::move(w); // surcharge (2)
    std::println("z = {}", z);
    std::println("w = {}", w); // w est dans un état valide mais non spécifié
    auto l = {4, 5, 6, 7};
    std::println("Assignation de initializer_list {} à x :", l);
    x = l; // surcharge (3)
    std::println("x = {}", x);
    std::println("L'assignation d'un initializer_list avec une taille supérieure à N lève une exception :");
    try
    {
        x = {1, 2, 3, 4, 5}; // lève une exception : (taille de la liste d'initialisation == 5) > (capacité N == 4)
    }
    catch(const std::bad_alloc& ex)
    {
        std::println("ex.what(): {}", ex.what());
    }
}

Sortie possible : 

Initialement :
x = [1, 2, 3]
y = []
L'assignation par copie copie les données de x vers y :
x = [1, 2, 3]
y = [1, 2, 3]
Initialement :
z = []
w = ["🐈", "💚"]
L'assignation par déplacement déplace les données de w vers z :
z = ["🐈", "💚"]
w = ["", ""]
Assignation de initializer_list [4, 5, 6, 7] à x :
x = [4, 5, 6, 7]
L'assignation d'un initializer_list avec une taille supérieure à N lève une exception :
ex.what(): std::bad_alloc

Voir aussi

construit le inplace_vector
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)