Namespaces
Variants

std::ranges:: uninitialized_fill

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Definiert in Header <memory>
Aufrufsignatur
template < no-throw-forward-iterator I, no - throw - sentinel - for < I > S,

class T >
requires std:: constructible_from < std:: iter_value_t < I > , const T & >

I uninitialized_fill ( I first, S last, const T & value ) ;
(1) (seit C++20)
(constexpr seit C++26)
template < no-throw-forward-range R, class T >

requires std:: constructible_from < ranges:: range_value_t < R > ,
const T & >
ranges:: borrowed_iterator_t < R > uninitialized_fill ( R && r,

const T & value ) ;
(2) (seit C++20)
(constexpr seit C++26)
1) Kopiert value in einen nicht initialisierten Speicherbereich [ first , last ) wie durch

for ( ; first ! = last ; ++ first )
:: new ( voidify ( * first ) ) std:: remove_reference_t < std:: iter_reference_t < I >> ( value ) ;
return first ;

Wenn während der Initialisierung eine Exception ausgelöst wird, werden die bereits konstruierten Objekte in einer nicht spezifizierten Reihenfolge zerstört.
2) Entspricht return ranges :: uninitialized_fill ( ranges:: begin ( r ) , ranges:: end ( r ) , value ) ; .

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind algorithm function objects (informell bekannt als niebloids ), das heißt:

Inhaltsverzeichnis

Parameter

first, last - das Iterator-Sentinel-Paar, das den Bereich der zu initialisierenden Elemente definiert
r - der range der zu initialisierenden Elemente
value - der Wert, mit dem die Elemente konstruiert werden sollen

Rückgabewert

Wie oben beschrieben.

Komplexität

Linear in der Größe des nicht initialisierten Speicherbereichs.

Exceptions

Jede Ausnahme, die beim Konstruieren der Elemente im Zielbereich ausgelöst wird.

Hinweise

Eine Implementierung kann die Effizienz von ranges::uninitialized_fill verbessern, z.B. durch Verwendung von ranges::fill , wenn der Werttyp des Ausgabebereichs ein TrivialType ist.

Feature-Test Makro Wert Std Funktion
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr für spezialisierte Speicheralgorithmen , ( 1,2 )

Mögliche Implementierung 

struct uninitialized_fill_fn
{
    template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S, class T>
        requires std::constructible_from<std::iter_value_t<I>, const T&>
    constexpr I operator()(I first, S last, const T& value) const
    {
        I rollback{first};
        try
        {
            for (; !(first == last); ++first)
                ranges::construct_at(std::addressof(*first), value);
            return first;
        }
        catch (...)
        {   
            // Rollback: Zerstöre konstruierte Elemente
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
    template<no-throw-forward-range R, class T>
        requires std::constructible_from<ranges::range_value_t<R>, const T&>
    constexpr ranges::borrowed_iterator_t<R> operator()(R&& r, const T& value) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), value);
    }
};
inline constexpr uninitialized_fill_fn uninitialized_fill{};

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <memory>
#include <string>
int main()
{
    constexpr int n{4};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];
    try
    {
        auto first{reinterpret_cast<std::string*>(out)};
        auto last{first + n};
        std::ranges::uninitialized_fill(first, last, "▄▀▄▀▄▀▄▀");
        int count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << *it << '\n';
        std::ranges::destroy(first, last);
    }
    catch(...)
    {
        std::cout << "Exception!\n";
    }
}

Ausgabe: 

1 ▄▀▄▀▄▀▄▀
2 ▄▀▄▀▄▀▄▀
3 ▄▀▄▀▄▀▄▀
4 ▄▀▄▀▄▀▄▀

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3870 C++20 dieser Algorithmus könnte Objekte auf einem const Speicher erstellen weiterhin nicht erlaubt

Siehe auch

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