std::uninitialized_fill

Défini dans l'en-tête `<memory>`
template< class NoThrowForwardIt, class T > void uninitialized_fill( NoThrowForwardIt first, NoThrowForwardIt last, const T& value );	(1)	(constexpr depuis C++26)
template< class ExecutionPolicy, class NoThrowForwardIt, class T > void uninitialized_fill( ExecutionPolicy&& policy, NoThrowForwardIt first, NoThrowForwardIt last, const T& value );	(2)	(depuis C++17)

1) Construit les éléments dans la plage de destination [first, last) avec la valeur donnée value comme si par

for (; first != last; ++first)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(value);

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 uniquement 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, last	-	la paire d'itérateurs définissant la plage d'éléments à initialiser
value	-	la valeur avec laquelle construire les éléments
policy	-	la politique d'exécution à utiliser
Exigences de type
- `NoThrowForwardIt` doit satisfaire aux exigences de LegacyForwardIterator .
- Aucun incrément, assignation, comparaison ou indirection via des instances valides de `NoThrowForwardIt` ne peut lever d'exceptions. L'application de & * à une valeur `NoThrowForwardIt` doit produire un pointeur vers son type de valeur. (jusqu'à C++11)

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 rattrapée est levée lors de l'accès aux objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour les politiques standard, std::terminate est invoqué).

Notes

Test de fonctionnalité macro	Valeur	Std	Fonctionnalité
`__cpp_lib_raw_memory_algorithms`	`202411L`	(C++26)	`constexpr` pour spécialisés `<memory>` algorithmes, (1)

Implémentation possible

template<class NoThrowForwardIt, class T>
constexpr void uninitialized_fill(NoThrowForwardIt first, NoThrowForwardIt last,
                                  const T& value)
{
    using V = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; current != last; ++current)
            ::new (static_cast<void*>(std::addressof(*current))) V(value);
    } 
    catch (...)
    {
        for (; first != current; ++first)
            first->~V();
        throw;
    }
}

Exemple

Exécuter ce code

#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
int main()
{
    const std::size_t sz = 4;
    std::allocator<std::string> alloc;
    std::string* p = alloc.allocate(sz);
    std::uninitialized_fill(p, p + sz, "Example");
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << '\n';
        i->~basic_string<char>();
    }
    alloc.deallocate(p, sz);
}

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 2433	C++11	cet algorithme pourrait être détourné par une surcharge de `operator&`	utilise std::addressof

Voir aussi

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

Support du compilateur
Indépendant 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 du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
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