Namespaces
Variants

    std::uninitialized_value_construct

    From de.cppreference.net
     
    C++
     
    Algorithmenbibliothek
    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)
    (C++11)
    Tauschoperationen
    Transformationsoperationen
    Generierungsoperationen
    Entfernungsoperationen
    Reihenfolgeänderungsoperationen
    (bis C++17)(C++11)
    (C++20)(C++20)
    Stichprobenoperationen
    (C++17)

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

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


     
    Spezialisierte <Speicher> Algorithmen
    Hilfsvorlagen (nur zur Darstellung*)
    (C++17)
    Objekt-(Stapel-)Konstruktion
    Objekt-(Stapel-)Zerstörung
    (C++17)
    (C++17)
    (C++17)
     
    Definiert in Header <memory> 
    template< class NoThrowForwardIt >
void uninitialized_value_construct( NoThrowForwardIt first,
                                    NoThrowForwardIt last );
    		(1) (seit C++17)
    (constexpr seit C++26)    		 
    template< class ExecutionPolicy, class NoThrowForwardIt >
void uninitialized_value_construct( ExecutionPolicy&& policy,
                                    NoThrowForwardIt first,
                                    NoThrowForwardIt last );
    		(2) (seit C++17)
    1) Konstruiert Elemente im Zielbereich [first, last) durch Wertinitialisierung als ob durch

    for (; first != last; ++first)
        ::new (voidify(*first))
            typename std::iterator_traits<NoThrowForwardIt>::value_type();

    Wenn während der Initialisierung eine Ausnahme ausgelöst wird, werden die bereits konstruierten Objekte in einer nicht spezifizierten Reihenfolge zerstört.
    2) Gleich wie (1), aber ausgeführt gemäß policy.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks true:

    std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

    		(bis C++20)

    std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

    		(seit C++20)

    Parameter

    first, last - das Paar von Iteratoren, das den Bereich der zu initialisierenden Elemente definiert
    policy - die zu verwendende Ausführungsrichtlinie
    Typanforderungen
    -
    NoThrowForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
    -
    Durch gültige Instanzen von NoThrowForwardIt dürfen keine Inkrement-, Zuweisungs-, Vergleichs- oder Dereferenzierungsoperationen Ausnahmen werfen.

    Ausnahmen

    2) Während des Ausführungsprozesses:
    • Falls die temporären Speicherressourcen, die für die Parallelisierung erforderlich sind, nicht verfügbar sind, std::bad_alloc wird geworfen.
    • Falls während des Zugriffs auf Objekte über ein Algorithmusargument eine nicht abgefangene Ausnahme geworfen wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien wird std::terminate aufgerufen).

    Anmerkungen

    Feature-TestMakro Wert Standard Feature
    __cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr für spezialisierte <memory> Algorithmen, (1)

    Mögliche Implementierung 

    template<class NoThrowForwardIt>
constexpr void uninitialized_value_construct(NoThrowForwardIt first,
                                             NoThrowForwardIt last)
{
    using Value = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; current != last; ++current)
        {
            ::new (static_cast<void*>(std::addressof(*current))) Value();
        }
    }
    catch (...)
    {
        std::destroy(first, current);
        throw;
    }
}

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <memory>
#include <string>
int main()
{
    struct S { std::string m{"Default value"}; };
    constexpr int n{3};
    alignas(alignof(S)) unsigned char mem[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(mem)};
        auto last{first + n};
        std::uninitialized_value_construct(first, last);
        for (auto it{first}; it != last; ++it)
            std::cout << it->m << '\n';
        std::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
    // For scalar types, uninitialized_value_construct
    // zero-fills the given uninitialized memory area.
    int v[]{1, 2, 3, 4};
    for (const int i : v)
        std::cout << i << ' ';
    std::cout << '\n';
    std::uninitialized_value_construct(std::begin(v), std::end(v));
    for (const int i : v)
        std::cout << i << ' ';
    std::cout << '\n';
}

    Ausgabe: 

    Default value
Default value
Default value
1 2 3 4
0 0 0 0

    Siehe auch

    (C++17)
    		konstruiert Objekte durch value-initialization in einem nicht initialisierten Speicherbereich, definiert durch Start und Anzahl
    (Funktions-Template)
    (C++17)
    		konstruiert Objekte durch default-initialization in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
    (Funktions-Template)
    (C++20)
    		konstruiert Objekte durch value-initialization in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
    (Algorithmus-Funktionsobjekt)