Namespaces
Variants

std::uninitialized_default_construct_n

Von de.cppreference.net
 
 
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)
Tauschoperationen
Transformationsoperationen
Erzeugungsoperationen
Entfernungsoperationen
Reihenfolgeändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortierung 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>
template< class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
    ( NoThrowForwardIt first, Size count );
(1) (seit C++17)
(constexpr seit C++26)
template< class ExecutionPolicy, class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
    ( ExecutionPolicy&& policy, NoThrowForwardIt first, Size count );
(2) (seit C++17)
1) Konstruiert Elemente im Zielbereich first + [0, count) durch Default-Initialisierung als ob 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 konstruierenden Elemente
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.

Rückgabewert

Wie oben beschrieben.

Ausnahmen

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 beim Zugriff auf Objekte über ein Algorithmusargument eine nicht gefangene Ausnahme ausgelöst wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien, std::terminate wird aufgerufen).

Anmerkungen

Feature-Test Makro Wert Std Merkmal
__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_default_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

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
struct S
{
    std::string m{"default value"};
};
int main()
{
    constexpr int n{3};
    alignas(alignof(S)) unsigned char mem[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(mem)};
        auto last = std::uninitialized_default_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_default_construct_n
    // generally does not zero-initialize the given uninitialized memory area.
    int v[]{1, 2, 3, 4};
    const int original[]{1, 2, 3, 4};
    std::uninitialized_default_construct_n(std::begin(v), std::size(v));
    // An attempt to access v might be an undefined behavior,
    // pending CWG 1997 to be resolved:
    // for (const int i : v)
    //     std::cout << i << ' ';
    // The result is unspecified:
    std::cout << (std::memcmp(v, original, sizeof(v)) == 0 ? "un" : "") << "modified\n";
}

Mögliche Ausgabe:

default value
default value
default value
unmodified

Siehe auch

konstruiert Objekte durch Default-Initialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
(Funktions-Template)
konstruiert Objekte durch Wert-Initialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Startpunkt und eine Anzahl
(Funktions-Template)
konstruiert Objekte durch Default-Initialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Startpunkt und eine Anzahl
(Algorithmus-Funktionsobjekt)