std::ranges:: uninitialized_default_construct_n

Construit des objets de type std:: iter_value_t < I > dans la zone mémoire non initialisée first + [ ​ 0 ​ , count ) par initialisation par défaut , comme par return ranges:: uninitialized_default_construct ( std:: counted_iterator ( first, count ) ,
std:: default_sentinel ) . 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'algorithmes (informellement appelés niebloids ), c'est-à-dire :

• Les listes d'arguments de modèle 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 omettre la construction des objets (sans modifier l'effet observable) si aucun constructeur par défaut non trivial n'est appelé lors de l'initialisation par défaut d'un std:: iter_value_t < I > objet, ce qui peut être détecté par std::is_trivially_default_constructible .

Notes

Implémentation possible

struct uninitialized_default_construct_n_fn
{
    template<no-throw-forward-iterator I>
        requires std::default_initializable<std::iter_value_t<I>>
    constexpr I operator()(I first, std::iter_difference_t<I> count) const
    {
        auto iter = std::counted_iterator(first, count);
        return ranges::uninitialized_default_construct(iter, std::default_sentinel).base();
    }
};
inline constexpr uninitialized_default_construct_n_fn uninitialized_default_construct_n{};

Exemple

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
int main()
{
    struct S { std::string m{"█▓▒░ █▓▒░ "}; };
    constexpr int n{4};
    alignas(alignof(S)) char out[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(out)};
        auto last = std::ranges::uninitialized_default_construct_n(first, n);
        auto count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << it->m << '\n';
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
    // Pour les types scalaires, uninitialized_default_construct_n
    // ne remplit généralement pas de zéros la zone mémoire non initialisée donnée.
    constexpr int sample[]{1, 2, 3, 4, 5, 6};
    int v[]{1, 2, 3, 4, 5, 6};
    std::ranges::uninitialized_default_construct_n(std::begin(v), std::size(v));
    if (std::memcmp(v, sample, sizeof(v)) == 0)
    {
        // Comportement potentiellement indéfini, en attente de CWG 1997 :
        // for (const int i : v) { std::cout << i << ' '; }
        for (const int i : sample)
            std::cout << i << ' ';
    }
    else
        std::cout << "Non spécifié !";
    std::cout << '\n';
}

1 █▓▒░ █▓▒░
2 █▓▒░ █▓▒░
3 █▓▒░ █▓▒░
4 █▓▒░ █▓▒░
1 2 3 4 5 6

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