std::uninitialized_fill_n

Défini dans l'en-tête `<memory>`
template< class NoThrowForwardIt, class Size, class T > NoThrowForwardIt uninitialized_fill_n( NoThrowForwardIt first, Size count, const T& value );	(1)	(constexpr depuis 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)	(depuis C++17)

1) Construit les premiers count éléments dans la plage de destination commençant à first avec la valeur donnée value comme si par

for (; count--; ++first)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(value);
return first;

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

2) Identique à (1), mais exécuté selon policy.

Cette surcharge participe à la résolution de surcharge seulement si la valeur de l'expression suivante est true:

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(jusqu'à C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(depuis C++20)

Paramètres

first	-	début de la plage des éléments à initialiser
count	-	nombre d'éléments à construire
value	-	valeur utilisée pour construire les éléments
Exigences de type
- `NoThrowForwardIt` doit satisfaire aux exigences de LegacyForwardIterator .
- Aucune incrémentation, assignation, comparaison ou indirection via des instances valides de `NoThrowForwardIt` ne doit lever d'exceptions. L'application de & * à une valeur `NoThrowForwardIt` doit produire un pointeur vers son type de valeur. (jusqu'à C++11)

Valeur de retour

Comme décrit ci-dessus.

Exceptions

2) Pendant le processus d'exécution :

Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est levée.
Si une exception non attrapée est levée lors de l'accès à des objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour politiques standard, std::terminate est invoqué).

Notes

macro Feature-test	Valeur	Norme	Fonctionnalité
`__cpp_lib_raw_memory_algorithms`	`202411L`	(C++26)	`constexpr` pour algorithmes `<memory>`spécialisés, (1)

Implémentation possible

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;
}

Exemple

Exécuter ce code

#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);
}

Sortie :

Example
Example
Example
Example

Rapports de défauts

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

DR	Appliqué à	Comportement tel que publié	Comportement correct
LWG 866	C++98	étant donné `T` comme type de valeur de `NoThrowForwardIt`, si `T::operator new` existe, le programme pourrait être mal formé	utilise le placement global `new` à la place
LWG 1339	C++98	la position du premier élément suivant la plage de remplissage n'a pas été retournée	retournée
LWG 2433	C++11	cet algorithme pourrait être détourné par une surcharge de `operator&`	utilise std::addressof

Voir aussi

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

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostic
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants