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) (seit C++26)
constexpr explicit inplace_vector ( size_type count ) ;
(2) (seit C++26)
constexpr inplace_vector ( size_type count, const T & value ) ;
(3) (seit C++26)
template < class InputIt >
constexpr inplace_vector ( InputIt first, InputIt last ) ;
(4) (seit C++26)
template < container-compatible-range < T > R >
constexpr inplace_vector ( std:: from_range_t , R && rg ) ;
(5) (seit C++26)
constexpr inplace_vector ( const inplace_vector & other ) ;
(6) (seit C++26)
constexpr inplace_vector ( inplace_vector && other )
noexcept ( N == 0 || std:: is_nothrow_move_constructible_v < T > ) ;
(7) (seit C++26)
constexpr inplace_vector ( std:: initializer_list < T > init ) ;
(8) (seit C++26)

Konstruiert einen neuen inplace_vector aus verschiedenen Datenquellen.

1) Konstruiert einen leeren inplace_vector , dessen data ( ) == nullptr und size ( ) == 0 ist.
2) Konstruiert einen inplace_vector mit count standardmäßig eingefügten Elementen.
3) Konstruiert einen inplace_vector mit count Kopien von Elementen mit dem Wert value .
4) Konstruiert einen inplace_vector mit den Inhalten des Bereichs [ first , last ) .
5) Konstruiert einen inplace_vector mit den Inhalten des Bereichs rg .
6) Ein copy constructor . Konstruiert einen inplace_vector mit der Kopie der Inhalte von other .
Der Konstruktor ist ein trivialer Kopierkonstruktor , wenn N > 0 und std:: is_trivially_copy_constructible_v < T > beide true sind.
7) Ein move constructor . Konstruiert einen inplace_vector mit den Inhalten von other unter Verwendung von Move-Semantik.
Der Konstruktor ist ein trivialer Move-Konstruktor , wenn N > 0 und std:: is_trivially_move_constructible_v < T > beide true sind.
8) Konstruiert einen inplace_vector mit den Inhalten der Initialisierungsliste init .

Inhaltsverzeichnis

Parameter

count - die Größe des Containers
value - der Wert, mit dem Elemente des Containers initialisiert werden
first, last - das Iteratorpaar, das den Quell- Bereich der zu kopierenden Elemente definiert
rg - der Wertebereich, mit dem Elemente des Containers initialisiert werden
other - ein weiterer inplace_vector , der als Quelle zur Initialisierung der Containerelemente verwendet wird
init - Initialisierungsliste zur Initialisierung der Containerelemente
Typanforderungen
-
T muss die Anforderungen von DefaultInsertable erfüllen, um die Überladungen (2,3) verwenden zu können.

Komplexität

1) Konstante.
2,3) Linear in count .
4) Linear in std:: distance ( first, last ) .
5) Linear in std :: ranges:: distance ( rg ) .
6,7) Linear in der Größe von other .
8) Linear in der Größe von init .

Ausnahmen

2,3) Wirft std::bad_alloc falls count > N .
5) Wirft std::bad_alloc falls std :: ranges:: size ( rg ) > N .
8) Wirft std::bad_alloc falls init. size ( ) > N .

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <initializer_list>
#include <inplace_vector>
#include <new>
#include <print>
#include <ranges>
int main()
{
    std::inplace_vector<int, 4> v1; // Überladung (1)
    assert(v1.size() == 0 && v1.capacity() == 4);
    std::inplace_vector<int, 0> v2; // Überladung (1), N == 0 ist erlaubt
    assert(v2.size() == 0 && v2.capacity() == 0);
    std::inplace_vector<int, 5> v3(3); // Überladung (2)
    assert(v3.size() == 3 && v3.capacity() == 5);
    std::println("v3 = {}", v3);
    try
    {
        std::inplace_vector<int, 3> v(4); // Überladung (2), wirft: count > N
    }
    catch(const std::bad_alloc& ex1)
    {
        std::println("ex1.what(): {}", ex1.was());
    }
    std::inplace_vector<int, 5> v4(3, 8); // Überladung (3)
    assert(v4.size() == 3 && v4.capacity() == 5);
    std::println("v4 = {}", v4);
    try
    {
        std::inplace_vector<int, 3> v(4, 2); // Überladung (3), wirft: count > N
    }
    catch(const std::bad_alloc& ex2)
    {
        std::println("ex2.what(): {}", ex2.was());
    }
    const auto init = {1, 2, 3};
    std::inplace_vector<int, 4> v5(init.begin(), init.end()); // Überladung (4)
    assert(v5.size() == 3 && v5.capacity() == 4);
    std::println("v5 = {}", v5);
    std::inplace_vector<int, 4> v6(std::from_range, init); // Überladung (5)
    assert(v6.size() == 3 && v6.capacity() == 4);
    std::println("v6 = {}", v6);
    std::inplace_vector<int, 4> v7(v6); // Überladung (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)); // Überladung (7)
    // Beachten Sie, dass nach dem Verschieben v6 in einem gültigen, aber unbestimmten Zustand verbleibt.
    assert(v8.size() == 3 && v8.capacity() == 4);
    std::println("v8 = {}", v8);
    std::inplace_vector<int, 4> v9(init); // Überladung (8)
    assert(v9.size() == 3 && v9.capacity() == 4);
    std::println("v9 = {}", v9);
    try
    {
        std::inplace_vector<int, 2> v(init); // Überladung (8), wirft: init.size() > N
    }
    catch(const std::bad_alloc& ex3)
    {
        std::println("ex3.what(): {}", ex3.was());
    }
}

Mögliche Ausgabe: 

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

Siehe auch

weist dem Container Werte zu
(öffentliche Elementfunktion)
[static]
gibt die Anzahl der Elemente zurück, die im aktuell allozierten Speicherplatz gehalten werden können
(öffentliche statische Elementfunktion)
direkter Zugriff auf den zugrundeliegenden zusammenhängenden Speicher
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück
(öffentliche Elementfunktion)
(C++17) (C++20)
gibt die Größe eines Containers oder Arrays zurück
(Funktionstemplate)
(C++17)
erhält den Zeiger auf das zugrundeliegende Array
(Funktionstemplate)