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)
Défini dans l'en-tête <memory>
Signature d'appel
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) (depuis C++20)
(constexpr depuis 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) (depuis C++20)
(constexpr depuis C++26)
1) Copie value vers une zone mémoire non initialisée [ first , last ) comme si par

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

Si une exception est levée durant l'initialisation, les objets déjà construits sont détruits dans un ordre non spécifié.
2) Équivalent à return ranges :: uninitialized_fill ( ranges:: begin ( r ) , ranges:: end ( r ) , value ) ; .

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithmes (informellement appelés niebloids ), c'est-à-dire :

Table des matières

Paramètres

first, last - la paire itérateur-sentinelle définissant l'intervalle des éléments à initialiser
r - l' range des éléments à initialiser
value - la valeur avec laquelle construire les éléments

Valeur de retour

Comme décrit ci-dessus.

Complexité

Linéaire dans la taille de la zone mémoire non initialisée.

Exceptions

Toute exception levée lors de la construction des éléments dans la plage de destination.

Notes

Une implémentation peut améliorer l'efficacité de ranges::uninitialized_fill , par exemple en utilisant ranges::fill , si le type de valeur de la plage de sortie est TrivialType .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr pour les algorithmes de mémoire spécialisés , ( 1,2 )

Implémentation possible 

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 (...)
        {   
            // restauration : détruire les éléments construits
            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{};

Exemple

Exécuter ce code 
#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";
    }
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 3870 C++20 cet algorithme pourrait créer des objets sur un const stockage maintenu interdit

Voir aussi

(C++20)
copie un objet vers une zone mémoire non initialisée, définie par un début et un compteur
(objet fonction algorithme)
copie un objet vers une zone mémoire non initialisée, définie par une plage
(modèle de fonction)