Namespaces
Variants

std::uninitialized_default_construct

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
Generierungsoperationen
Entfernungsoperationen
Reihenfolgeändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortierungs- und verwandte Operationen
Partitionierungsoperationen
(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
Permutationsoperationen


 
 
Definiert in Header <memory>
template< class NoThrowForwardIt >
void uninitialized_default_construct( NoThrowForwardIt first,
                                      NoThrowForwardIt last );
(1) (seit C++17)
(constexpr seit C++26)
template< class ExecutionPolicy, class NoThrowForwardIt >
void uninitialized_default_construct( ExecutionPolicy&& policy,
                                      NoThrowForwardIt first,
                                      NoThrowForwardIt last );
(2) (seit C++17)
1) Konstruiert Elemente im Zielbereich [first, last) durch Default-Initialisierung 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 Inkrementierungen, Zuweisungen, Vergleiche oder Dereferenzierungen Ausnahmen auslösen.

Ausnahmen

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

Anmerkungen

Feature-TestMakro Wert Std 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_default_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

#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{first + n};
        std::uninitialized_default_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_default_construct
    // generally does not zero-fill the given uninitialized memory area.
    int v[]{1, 2, 3, 4};
    const int original[]{1, 2, 3, 4};
    std::uninitialized_default_construct(std::begin(v), std::end(v));
    // Maybe 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 ? "Unmodified\n" : "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 Start und Anzahl
(Funktions-Template)
konstruiert Objekte durch Value-Initialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
(Funktions-Template)
konstruiert Objekte durch Default-Initialisierung in einem nicht initialisierten Speicherbereich, definiert durch einen Bereich
(Algorithmus-Funktionsobjekt)