std::ranges:: uninitialized_fill_n

Copie value vers une zone mémoire non initialisée first + [ ​ 0 ​ , count ) comme par return ranges:: uninitialized_fill ( std:: counted_iterator ( first, count ) ,
std:: default_sentinel , value ) . base ( ) ;

Si une exception est levée pendant l'initialisation, les objets déjà construits sont détruits dans un ordre non spécifié.

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

• Les listes d'arguments de template explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
• Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
• Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

Valeur de retour

Comme décrit ci-dessus.

Complexité

Linéaire en count .

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_n , par exemple en utilisant ranges::fill_n , si le type de valeur de la plage de sortie est TrivialType .

Implémentation possible

struct uninitialized_fill_n_fn
{
    template<no-throw-forward-range I, class T>
    requires std::constructible_from<std::iter_value_t<I>, const T&>
    I operator()(I first, std::iter_difference_t<I> n, const T& x) const
    {
        I rollback{first};
        try
        {
            for (; n-- > 0; ++first)
                ranges::construct_at(std::addressof(*first), x);
            return first;
        }
        catch (...) // restauration : détruire les éléments construits
        {
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
};
inline constexpr uninitialized_fill_n_fn uninitialized_fill_n{};

Exemple

#include <iostream>
#include <memory>
#include <string>
int main()
{
    constexpr int n{3};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];
    try
    {
        auto first{reinterpret_cast<std::string*>(out)};
        auto last = std::ranges::uninitialized_fill_n(first, n, "cppreference");
        for (auto it{first}; it != last; ++it)
            std::cout << *it << '\n';
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
}

cppreference
cppreference
cppreference

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.

Voir aussi