Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::inplace_vector
Member types
Member functions
Non-member functions
constexpr inplace_vector ( ) noexcept ;
(1) (depuis C++26)
constexpr explicit inplace_vector ( size_type count ) ;
(2) (depuis C++26)
constexpr inplace_vector ( size_type count, const T & value ) ;
(3) (depuis C++26)
template < class InputIt >
constexpr inplace_vector ( InputIt first, InputIt last ) ;
(4) (depuis C++26)
template < container-compatible-range < T > R >
constexpr inplace_vector ( std:: from_range_t , R && rg ) ;
(5) (depuis C++26)
constexpr inplace_vector ( const inplace_vector & other ) ;
(6) (depuis C++26)
constexpr inplace_vector ( inplace_vector && other )
noexcept ( N == 0 || std:: is_nothrow_move_constructible_v < T > ) ;
(7) (depuis C++26)
constexpr inplace_vector ( std:: initializer_list < T > init ) ;
(8) (depuis C++26)

Construit un nouveau inplace_vector à partir de diverses sources de données.

1) Construit un inplace_vector vide dont data ( ) == nullptr et size ( ) == 0 .
2) Construit un inplace_vector avec count éléments insérés par défaut.
3) Construit un inplace_vector avec count copies d'éléments de valeur value .
4) Construit un inplace_vector avec le contenu de la plage [ first , last ) .
5) Construit un inplace_vector avec le contenu de la plage rg .
6) Un copy constructor . Construit un inplace_vector avec la copie du contenu de other .
Le constructeur est un constructeur de copie trivial si N > 0 et std:: is_trivially_copy_constructible_v < T > sont tous deux true .
7) Un move constructor . Construit un inplace_vector avec le contenu de other en utilisant la sémantique de déplacement.
Le constructeur est un constructeur de déplacement trivial si N > 0 et std:: is_trivially_move_constructible_v < T > sont tous deux true .
8) Construit un inplace_vector avec le contenu de la liste d'initialisation init .

Table des matières

Paramètres

count - la taille du conteneur
value - la valeur pour initialiser les éléments du conteneur
first, last - la paire d'itérateurs définissant la plage source des éléments à copier
rg - la plage de valeurs pour initialiser les éléments du conteneur
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
Exigences de type
-
T doit satisfaire aux exigences de DefaultInsertable pour utiliser les surcharges (2,3).

Complexité

1) Constante.
2,3) Linéaire en count .
4) Linéaire en std:: distance ( first, last ) .
5) Linéaire en std :: ranges:: distance ( rg ) .
6,7) Linéaire en fonction de la taille de other .
8) Linéaire en fonction de la taille de init .

Exceptions

2,3) Lance std::bad_alloc si count > N .
5) Lance std::bad_alloc si std :: ranges:: size ( rg ) > N .
8) Lève std::bad_alloc si init. size ( ) > N .

Exemple

Exécuter ce code 
#include <cassert>
#include <initializer_list>
#include <inplace_vector>
#include <new>
#include <print>
#include <ranges>
int main()
{
    std::inplace_vector<int, 4> v1; // surcharge (1)
    assert(v1.size() == 0 && v1.capacity() == 4);
    std::inplace_vector<int, 0> v2; // surcharge (1), N == 0 est autorisé
    assert(v2.size() == 0 && v2.capacity() == 0);
    std::inplace_vector<int, 5> v3(3); // surcharge (2)
    assert(v3.size() == 3 && v3.capacity() == 5);
    std::println("v3 = {}", v3);
    try
    {
        std::inplace_vector<int, 3> v(4); // surcharge (2), lève : count > N
    }
    catch(const std::bad_alloc& ex1)
    {
        std::println("ex1.what(): {}", ex1.what());
    }
    std::inplace_vector<int, 5> v4(3, 8); // surcharge (3)
    assert(v4.size() == 3 && v4.capacity() == 5);
    std::println("v4 = {}", v4);
    try
    {
        std::inplace_vector<int, 3> v(4, 2); // surcharge (3), lève : count > N
    }
    catch(const std::bad_alloc& ex2)
    {
        std::println("ex2.what(): {}", ex2.what());
    }
    const auto init = {1, 2, 3};
    std::inplace_vector<int, 4> v5(init.begin(), init.end()); // surcharge (4)
    assert(v5.size() == 3 && v5.capacity() == 4);
    std::println("v5 = {}", v5);
    std::inplace_vector<int, 4> v6(std::from_range, init); // surcharge (5)
    assert(v6.size() == 3 && v6.capacity() == 4);
    std::println("v6 = {}", v6);
    std::inplace_vector<int, 4> v7(v6); // surcharge (6)
    assert(v7.size() == 3 && v7.capacity() == 4);
    std::println("v7 = {}", v7);
    assert(v6.size() == 3);
    std::inplace_vector<int, 4> v8(std::move(v6)); // surcharge (7)
    // Notez qu'après le déplacement, v6 est laissé dans un état valide mais indéterminé.
    assert(v8.size() == 3 && v8.capacity() == 4);
    std::println("v8 = {}", v8);
    std::inplace_vector<int, 4> v9(init); // surcharge (8)
    assert(v9.size() == 3 && v9.capacity() == 4);
    std::println("v9 = {}", v9);
    try
    {
        std::inplace_vector<int, 2> v(init); // surcharge (8), lève : init.size() > N
    }
    catch(const std::bad_alloc& ex3)
    {
        std::println("ex3.what(): {}", ex3.what());
    }
}

Sortie possible : 

v3 = [0, 0, 0]
ex1.what(): std::bad_alloc
v4 = [42, 42, 42]
ex2.what(): std::bad_alloc
v5 = [1, 2, 3]
v6 = [1, 2, 3]
v7 = [1, 2, 3]
v8 = [1, 2, 3]
v9 = [1, 2, 3]
ex3.what(): std::bad_alloc

Voir aussi

assigne des valeurs au conteneur
(fonction membre publique)
[static]
retourne le nombre d'éléments pouvant être contenus dans le stockage actuellement alloué
(fonction membre publique statique)
accès direct au stockage contigu sous-jacent
(fonction membre publique)
retourne le nombre d'éléments
(fonction membre publique)
(C++17) (C++20)
retourne la taille d'un conteneur ou d'un tableau
(fonction template)
(C++17)
obtient le pointeur vers le tableau sous-jacent
(fonction template)