Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::generate : remplissage par résultats de générateur

std::generate appelle un générateur sans argument exactement une fois par position et affecte chaque résultat successif.

Version : C++23

Syntaxe

template<class ForwardIt, class Generator>
constexpr void std::generate(ForwardIt first, ForwardIt last, Generator gen);

template<class ExecutionPolicy, class ForwardIt, class Generator>
void std::generate(ExecutionPolicy&& policy,
    ForwardIt first, ForwardIt last, Generator gen);

std::generate(first, last, gen) de <algorithm> parcourt une plage d’itérateurs forward et affecte à chaque élément le résultat d’un nouvel appel gen(). La surcharge sans politique renvoie void et exige au moins un itérateur forward. Pour N éléments, elle effectue exactement N évaluations du générateur et N affectations. std::ranges::generate accepte un itérateur input-or-output et renvoie l’itérateur final.

L’exemple crée un tableau de quatre éléments et fournit une lambda qui avance next. Les appels renvoient 2, 4, 6 puis 8 ; le programme affiche donc 2 4 6 8 suivi d’un saut de ligne. L’état capturé par référence est sûr dans cet appel séquentiel. Le générateur est toutefois passé par valeur à l’algorithme : il ne faut pas dépendre de l’état ultérieur de l’objet original.

La plage doit accepter les résultats de gen(). Sans politique, une exception du générateur ou de l’affectation se propage et les éléments déjà écrits restent modifiés. Avec toute ExecutionPolicy standard, une exception non interceptée d’une opération d’élément entraîne std::terminate ; un manque de mémoire temporaire de parallélisation peut lancer std::bad_alloc. La version avec politique peut copier le générateur et invoquer les copies sans ordre ou en parallèle : un compteur partagé non synchronisé crée une data race. std::generate_n ne produit rien si n n’est pas positif.

Exemples

#include <algorithm>
#include <array>
#include <iostream>

int main() {
    std::array<int, 4> values{};
    int next = 1;
    std::generate(values.begin(), values.end(), [&next] {
        return 2 * next++;
    });

    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}

Résultat

2 4 6 8 

std::generate → 2 4 6 8

Sources