Namespaces
Variants

std::ranges::uninitialized_value_construct_n

Von de.cppreference.net
 
 
Algorithmusbibliothek
Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
Eingeschränkte Algorithmen, z. B. ranges::copy, ranges::sort, ...
Nicht modifizierende Sequenzoperationen    
Stapeloperationen
(C++17)
Suchoperationen
Modifizierende Sequenzoperationen
Kopieroperationen
(C++11)
(C++11)
Tauschoperationen
Transformationsoperationen
Erzeugungsoperationen
Entfernungsoperationen
Reihenfolgeändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortier- und verwandte Operationen
Partitionierungsoperationen
(C++11)    

Sortieroperationen
Binäre Suchoperationen
(auf partitionierten Bereichen)
Mengenoperationen (auf sortierten Bereichen)
Mischoperationen (auf sortierten Bereichen)
Heap-Operationen
Minimum/Maximum-Operationen
(C++11)
(C++17)
Lexikografische Vergleichsoperationen
Permutationsoperationen


 
 
Definiert in Header <memory>
Aufrufsignatur
template< /*nothrow-forward-iterator*/ I >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_value_construct_n( I first,
                                   std::iter_difference_t<I> count );
(1) (seit C++20)
(constexpr seit C++26)
template< /*execution-policy*/ Ep, /*nothrow-random-access-iterator*/ I >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_value_construct_n( Ep&& policy, I first,
                                   std::iter_difference_t<I> count );
(2) (seit C++26)

Für die Definition von /*execution-policy*/, siehe diese Seite; für die Definition anderer nur zur Erläuterung dienender Konzepte siehe diese Seite.

1) Konstruiert Elemente im Zielbereich first + [0, count) durch Wertinitialisierung (value-initialization) wie durch

return ranges::uninitialized_value_construct(std::counted_iterator(first, count),
                                             std::default_sentinel).base();

Wenn während der Initialisierung eine Ausnahme ausgelöst wird, werden die bereits konstruierten Objekte in einer nicht spezifizierten Reihenfolge zerstört.
2) Wie (1), aber ausgeführt gemäß policy.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als Niebloids bezeichnet), das heißt:

Parameter

first – den Anfang des Bereichs der zu initialisierenden Elemente
count – die Anzahl der zu konstruierenden Elemente
policy – die Ausführungsrichtlinie zu verwenden

Rückgabewert

Wie oben beschrieben.

Ausnahmen

Jede Ausnahme, die beim Konstruieren der Elemente im Zielbereich ausgelöst wird.

2) Während des Ausführungsprozesses:
  • Wenn die für die Parallelisierung erforderlichen temporären Speicherressourcen nicht verfügbar sind, std::bad_alloc wird ausgelöst.
  • Wenn eine nicht abgefangene Ausnahme beim Zugriff auf Objekte über ein Algorithmusargument ausgelöst wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für standard policies, std::terminate wird aufgerufen).

Hinweise

Eine Implementierung kann die Effizienz der ranges::uninitialized_value_construct_n (indem z. B. ranges::fill_n) verbessern, wenn der Werttyp des Bereichs ein CopyAssignable TrivialType ist.

Feature-Test Makro Wert Std Feature
__cpp_lib_parallel_algorithm 202506L (C++26) Parallele Range-Algorithmen
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr für spezialisierte <memory> Algorithmen, (1)

Mögliche Implementierung

struct uninitialized_value_construct_n_fn
{
    template</*nothrow-forward-iterator*/ I>
        requires std::default_initializable<std::iter_value_t<I>>
    constexpr I operator()(I first, std::iter_difference_t<I> count) const
    {
        auto iter = std::counted_iterator(first, count);
        return ranges::uninitialized_value_construct(iter, std::default_sentinel).base();
    }
};

inline constexpr uninitialized_value_construct_n_fn uninitialized_value_construct_n{};

Beispiel

#include <iostream>
#include <memory>
#include <string>
int main()
{
    struct S { std::string m{"█▓▒░ █▓▒░ █▓▒░ "}; };
    constexpr int n{4};
    alignas(alignof(S)) char out[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(out)};
        auto last = std::ranges::uninitialized_value_construct_n(first, n);
        auto count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << it->m << '\n';
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
    // For scalar types, uninitialized_value_construct_n
    // zero-initializes the given uninitialized memory area.
    int v[]{1, 2, 3, 4, 5, 6, 7, 8};
    std::cout << ' ';
    for (const int i : v)
        std::cout << i << ' ';
    std::cout << "\n ";
    std::ranges::uninitialized_value_construct_n(std::begin(v), std::size(v));
    for (const int i : v)
        std::cout << i << ' ';
    std::cout << '\n';
}

Ausgabe:

1 █▓▒░ █▓▒░ █▓▒░ 
2 █▓▒░ █▓▒░ █▓▒░ 
3 █▓▒░ █▓▒░ █▓▒░ 
4 █▓▒░ █▓▒░ █▓▒░
1 2 3 4 5 6 7 8
0 0 0 0 0 0 0 0

Siehe auch

erstellt Objekte durch Wertinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
(Algorithmus-Funktionsobjekt)
erstellt Objekte durch Standardinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
(Algorithmus-Funktionsobjekt)
erstellt Objekte durch Standardinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Start und eine Anzahl
(Algorithmus-Funktionsobjekt)
erstellt Objekte durch Wertinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Start und eine Anzahl
(Funktionstemplate)