Namespaces
Variants

std:: generate_n

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
generate_n
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <algorithm>
template < class OutputIt, class Size, class Generator >
OutputIt generate_n ( OutputIt first, Size count, Generator g ) ;
(1) (constexpr depuis C++20)
template < class ExecutionPolicy,

class ForwardIt, class Size, class Generator >
ForwardIt generate_n ( ExecutionPolicy && policy,

ForwardIt first, Size count, Generator g ) ;
(2) (depuis C++17)
1) Attribue des valeurs, générées par l'objet fonction donné g , aux premiers count éléments dans la plage commençant à first , si count > 0 . Ne fait rien sinon.
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)

Si Size n'est pas convertible en un type intégral , le programme est mal formé.

Table des matières

Paramètres

first - début de la plage d'éléments à générer
count - nombre d'éléments à générer
policy - la politique d'exécution à utiliser
g - objet fonction générateur qui sera appelé.

La signature de la fonction doit être équivalente à ce qui suit :

Ret fun ( ) ;

Le type Ret doit être tel qu'un objet de type OutputIt puisse être déréférencé et assigné à une valeur de type Ret . ​

Exigences de type
-
OutputIt doit satisfaire aux exigences de LegacyOutputIterator .
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator .

Valeur de retour

Itérateur pointant après le dernier élément assigné si count > 0 , first sinon.

Complexité

Exactement std:: max ( 0 , count ) invocations de g ( ) et assignations.

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é. 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é.

Implémentation possible 

template<class OutputIt, class Size, class Generator>
constexpr // depuis C++20
OutputIt generate_n(OutputIt first, Size count, Generator g)
{
    for (Size i = 0; i < count; ++i, ++first)
        *first = g();
    return first;
}

Exemple

Exécuter ce code 
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <random>
int main()
{
    std::mt19937 rng; // construction par défaut, amorcé avec une graine fixe
    std::generate_n(std::ostream_iterator<std::mt19937::result_type>(std::cout, " "),
                    5, std::ref(rng));
    std::cout << '\n';
}

Sortie : 

3499211612 581869302 3890346734 3586334585 545404204

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 Applicable à Comportement publié Comportement corrigé
LWG 426 C++98 l'exigence de complexité était « exactement count invocations
ou affectations », ce qui est incorrect si count est négatif 		aucune invocation ni affectation
si count est non positif
LWG 865 C++98 la position du premier élément suivant
la plage de génération n'était pas renvoyée 		renvoyée

Voir aussi

assigne par copie la valeur donnée à N éléments dans une plage
(modèle de fonction)
assigne les résultats d'appels successifs de fonction à chaque élément d'une plage
(modèle de fonction)
(C++20)
sauvegarde le résultat de N applications d'une fonction
(objet fonction algorithme)