Salut à toutes et à tous !

Quelle syntaxe est à préférer lorsque l'on crée des foncteurs de simulation pour lesquels des générateurs de nombre aléatoires sont nécessaires ?

Transmettre le générateur à l'appel de fonction:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
std::mt19937 gen;
auto f = [](auto& generator, int arg){ return some_simulation_code(generator, arg); };
f(gen, 3);
ou transmettre le générateur à la construction:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
std::mt19937 gen;
auto g = [& gen](int arg){ return some_simulation_code(gen, arg); };
g(3);


Mon sentiment est que peut-être que j'aimerais bien me rappeler à l'appel de la fonction qu'elle ne renverra pas deux fois la même chose, et que j'aimerais coller un peu à la syntaxe de la STL qui file le générateur à l'appel de l'opérateur (il doit y avoir une raison pour laquelle ils font ça ).

D'un autre côté quand pas mal de code repose sur l'interface operator()(int), et que le modèle mathématique sous jacent est défini par des fonctions d'entiers, j'imagine qu'on peut légitimement mettre un générateur en membre de classe pour garder une certaine uniformité ?

Mais d'encore un autre côté la construction du foncteur peut avoir lieu à un endroit éloigné de là où est construit le générateur (pour l'instant c'est pas trop le cas), du coup ça peut valoir le coup de retarder le moment où les deux se rencontrent.

Quelle est la manière standard de faire ? (celle de la STL j'imagine ).
Bien à vous,