std::generate
Depuis fr.cppreference.net
< cpp | algorithme
| Défini dans l'en-tête <algorithm>
|
||
template< class ForwardIt, class Generator >
void generate( ForwardIt first, ForwardIt last, Generator g );
|
(1) | (constexpr depuis C++20) |
template< class ExecutionPolicy, class ForwardIt, class Generator >
void generate( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last, Generator g );
|
(2) | (depuis C++17) |
1) Assigne à chaque élément de la plage
[first, last) une valeur générée par l'objet fonction donné g.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:
|
|
(jusqu'à C++20) |
|
|
(depuis C++20) |
Paramètres
| first, last | - | la paire d'itérateurs définissant la plage 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 à la suivante :
Le type | ||||||
| Exigences de type | ||||||||
-ForwardIt doit satisfaire les exigences de LegacyForwardIterator.
| ||||||||
Complexité
Exactement std::distance(first, last) invocations de g() et assignations.
Exceptions
La surcharge avec un paramètre template 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
ExecutionPolicyest l'une des politiques standard, std::terminate est appelé. Pour tout autreExecutionPolicy, 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.
Implémentation possible
template<class ForwardIt, class Generator>
constexpr //< since C++20
void generate(ForwardIt first, ForwardIt last, Generator g)
{
for (; first != last; ++first)
*first = g();
}
|
Exemple
Exécuter ce code
#include <algorithm>
#include <iostream>
#include <vector>
void println(std::string_view fmt, const auto& v)
{
for (std::cout << fmt; const auto& e : v)
std::cout << e << ' ';
std::cout << '\n';
};
int f()
{
static int i;
return ++i;
}
int main()
{
std::vector<int> v(5);
std::generate(v.begin(), v.end(), f);
println("v: ", v);
// Initialize with default values 0,1,2,3,4 from a lambda function
// Equivalent to std::iota(v.begin(), v.end(), 0);
std::generate(v.begin(), v.end(), [n = 0] () mutable { return n++; });
println("v: ", v);
}
Sortie :
v: 1 2 3 4 5
v: 0 1 2 3 4
Voir aussi
| assigne par copie la valeur donnée à chaque élément d'une plage (fonction template & objet fonction d'algorithme) | |
(C++20) |
|
| assigne les résultats d'appels successifs de fonction à N éléments d'une plage (fonction template & objet fonction d'algorithme) | |
(C++20) |
|
(C++11) |
remplit une plage avec des incréments successifs de la valeur de départ (fonction template & objet fonction d'algorithme) |
(C++23) |
|
(C++20) |
sauvegarde le résultat d'une fonction dans une plage (objet fonction d'algorithme) |