Namespaces
Variants

std:: uninitialized_fill_n

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>
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) Copie value vers une zone mémoire non initialisée first + [ ​ 0 ​ , count ) comme par

for ( ; count -- ; ++ first )
:: new ( voidify ( * first ) )
typename std:: iterator_traits < NoThrowForwardIt > :: value_type ( 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) Identique à (1) , mais exécuté selon la policy .
Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> est true .

(jusqu'à C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> est true .

(depuis C++20)

Table des matières

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.

Complexité

Linéaire en count .

Exceptions

La surcharge avec un paramètre de modèle nommé ExecutionPolicy signale les erreurs comme suit :

  • Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelée. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Notes

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 )

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 modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement tel que publié Comportement corrigé
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'était pas retournée 		retournée
LWG 2433 C++11 cet algorithme pourrait être détourné par operator & surchargé utilise std::addressof
LWG 3870 C++20 cet algorithme pourrait créer des objets sur un const stockage maintenu interdit

Voir aussi

copie un objet vers une zone mémoire non initialisée, définie par une plage
(modèle de fonction)
(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)