Namespaces
Variants

    std::uninitialized_value_construct_n

    Von 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
    Erzeugungsoperationen
    Entfernungsoperationen
    Reihenfolgeändernde Operationen
    (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/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     
    Spezialisierte <memory> Algorithmen
    Hilfsvorlagen (nur zur Veranschaulichung*)
    (C++17)
    Objekt (Stapel) Konstruktion
    Objekt (Stapel) Zerstörung
    (C++17)
    (C++17)
    (C++17)
     
    Definiert in Header <memory> 
    template< class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_value_construct_n
    ( NoThrowForwardIt first, Size count );
    		(1) (seit C++17)
    (constexpr seit C++26)    		 
    template< class ExecutionPolicy, class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_value_construct_n
    ( ExecutionPolicy&& policy, NoThrowForwardIt first, Size count );
    		(2) (seit C++17)
    1) Konstruiert Elemente im Zielbereich first + [0, count) durch Wertinitialisierung wie durch

    for (; count > 0; (void)++first, --count)
        ::new (voidify(*first))
            typename std::iterator_traits<NoThrowForwardIt>::value_type();
    return first;

    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 ist:

    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 - der Anfang des Bereichs der zu initialisierenden Elemente
    count - die Anzahl der zu initialisierenden Elemente
    policy - die Ausführungsrichtlinie zu verwenden
    Typanforderungen
    -
    NoThrowForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
    -
    Durch gültige Instanzen von NoThrowForwardIt dürfen keine Ausnahmen bei Inkrementierung, Zuweisung, Vergleich oder Dereferenzierung geworfen werden.

    Rückgabewert

    Wie oben beschrieben.

    Ausnahmen

    2) Während des Ausführungsprozesses:
    • Falls die für die Parallelisierung erforderlichen temporären Speicherressourcen nicht verfügbar sind, std::bad_alloc wird geworfen.
    • Falls beim Zugriff auf Objekte über ein Algorithmus-Argument eine nicht abgefangene Ausnahme ausgelöst wird, wird das Verhalten durch die Ausführungsstrategie bestimmt (für Standardstrategien, std::terminate wird aufgerufen).

    Hinweise

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

    Mögliche Implementierung 

    template<class NoThrowForwardIt, class Size>
constexpr ForwardIt uninitialized_value_construct_n(NoThrowForwardIt first, Size count)
{
    using T = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; countn > 0; (void) ++current, --count)
            ::new (static_cast<void*>(std::addressof(*current))) T();
        return current;
    }
    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 = std::uninitialized_value_construct_n(first, n);
        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_n
    // zero-initializes 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_n(std::begin(v), std::size(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 Wertinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
    (Funktions-Template)
    (C++17)
    		konstruiert Objekte durch Standardinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Startpunkt und eine Anzahl
    (Funktions-Template)
    (C++20)
    		konstruiert Objekte durch Wertinitialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Startpunkt und eine Anzahl
    (Algorithmus-Funktionsobjekt)