Namespaces
Variants

    std::uninitialized_fill_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 <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, class Size, class T >
NoThrowForwardIt uninitialized_fill_n( NoThrowForwardIt first,
                                       Size count, const T& value );
    		(1) (constexpr seit C++26) 
    template< class ExecutionPolicy,
          class NoThrowForwardIt, class Size, class T >
NoThrowForwardIt uninitialized_fill_n( ExecutionPolicy&& policy,
                                       NoThrowForwardIt first,
                                       Size count, const T& value );
    		(2) (seit C++17)
    1) Konstruiert die ersten count Elemente im Zielbereich, beginnend bei first mit dem gegebenen Wert value als ob durch

    for (; count--; ++first)
        ::new (voidify(*first))
            typename std::iterator_traits<NoThrowForwardIt>::value_type(value);
    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) 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 - Anzahl der zu konstruierenden Elemente
    value - der Wert, mit dem die Elemente konstruiert werden
    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. Die Anwendung von & * auf einen NoThrowForwardIt -Wert muss einen Zeiger auf seinen Werttyp liefern. (bis C++11)

    Rückgabewert

    Wie oben beschrieben.

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

    Anmerkungen

    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, class T>
constexpr NoThrowForwardIt uninitialized_fill_n(NoThrowForwardIt first,
                                                Size count, const T& value)
{
    using V = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; count > 0; ++current, (void) --count)
            ::new (static_cast<void*>(std::addressof(*current))) V(value);
        return current;
    }
    catch (...)
    {
        for (; first != current; ++first)
            first->~V();
        throw;
    }
    return current;
}

    Beispiel

    Diesen Code ausführen 
    #include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
int main()
{
    std::string* p;
    std::size_t sz;
    std::tie(p, sz) = std::get_temporary_buffer<std::string>(4);
    std::uninitialized_fill_n(p, sz, "Example");
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << '\n';
        i->~basic_string<char>();
    }
    std::return_temporary_buffer(p);
}

    Ausgabe: 

    Example
Example
Example
Example

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 866 C++98 gegeben T als der Werttyp von NoThrowForwardIt, falls
    T::operator new existiert, könnte das Programm fehlerhaft sein     		verwendet globales Placement new stattdessen
    LWG 1339 C++98 die Position des ersten Elements folgend
    dem Füllbereich wurde nicht zurückgegeben     		zurückgegeben
    LWG 2433 C++11 dieser Algorithmus könnte gekapert werden von überladenem operator& verwendet std::addressof

    Siehe auch

    		kopiert ein Objekt in einen nicht initialisierten Speicherbereich, definiert durch einen Bereich
    (Funktions-Template)
    (C++20)
    		kopiert ein Objekt in einen nicht initialisierten Speicherbereich, definiert durch einen Startpunkt und eine Anzahl
    (Algorithmus-Funktionsobjekt)