Discussion :

[Seabirds]

Salut à toutes et à tous !
Je dois générer un gros paquets de combinaisons.
L'algorithme que j'essaie d'implémenter a été implémenté en Ruby et Python, et tous deux y font l'usage intensif de générateurs (le mignon yield). J'essaie de traduire le code en C++, sauf que les générateurs ne semblent pas supportés par C++.
Mes recherches sur internet portent sur deux manières de faire (qui sont résumées sur la page Wikipedia, https://en.wikipedia.org/wiki/Genera...mming)#C.2B.2B ).
La première solution consiste à utiliser une directive macro pour utiliser le mot clé yield. Les exemples wiki sont assez parlant, une implémentation est disponible ici. Cette solution me paraît raisonnablement simple et ne perturbe pas trop le code que je calque. Reproches qui semblent généralement fait : ça ne fait pas trop "C++", et les macros on m'a dit qu'il fallait faire très attention.
La deuxième solution consiste à utilise le C++11 et les itérables. Avantage apparent, ça semble être plus fidèle à la manière C++ de faire. Au moins sur une exemple simple (celui de wikipedia), ça me semble facile à implémenter.
Par contre, sachant que mon algorithme est un poil tordu quand même (appel de fonctions récursives, des yield en folie, voir ci-dessous), quelle approche me conseilleriez vous ?

Cordialement,

Un échantillon du code en Python (je suis toujours aussi choqué du typage inexistant, en fait ça rend les algos super dur à comprendre )

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
    def f(mu, nu, sigma, n, a):
        if mu == 2:
            yield visit(n, a)
        else:
            for v in f(mu - 1, nu - 1, (mu + sigma) % 2, n, a):
                yield v
        if nu == mu + 1:
            a[mu] = mu - 1
            yield visit(n, a)
            while a[nu] > 0:
                a[nu] = a[nu] - 1
                yield visit(n, a)
        elif nu > mu + 1:
            if (mu + sigma) % 2 == 1:
                a[nu - 1] = mu - 1
            else:
                a[mu] = mu - 1
            if (a[nu] + sigma) % 2 == 1:
                for v in b(mu, nu - 1, 0, n, a):
                    yield v
            else:
                for v in f(mu, nu - 1, 0, n, a):
                    yield v
            while a[nu] > 0:
                a[nu] = a[nu] - 1
                if (a[nu] + sigma) % 2 == 1:
                    for v in b(mu, nu - 1, 0, n, a):
                        yield v
                else:
                    for v in f(mu, nu - 1, 0, n, a):
                        yield v

[Bousk]

Ou bien utiliser une classe intermédiaire que tu utilises comme générateur. Et y'a fort à parier que c'est ce qui est sous la logique derrière ceux de Python et consors.
Une telle classe pourrait avoir une interface du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class Generator {
public:
  Generator(int start, int end) {}
  int next() {}
  bool finished() const {}
};

que tu utilises comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Generator g;
for(int i = g.next(); !g.finished(); i = g.next()) {}

Tu peux aussi implémenter Generator pour utiliser les itérateurs et utiliser la syntaxe for( int i : g) mais ne l'ayant jamais réalisé je ne connais pas la syntaxe spécifique.
Parce qu'un générator ça reste un objet qui a un état que l'on interroge et qui change à chaque fois qu'on lui requête la donnée suivante.

[jo_link_noir]

Transformer ce truc en itérateur va être terrible. Les itérateurs sont bien pour les algos qui n'utilisent qu'un seul yield, en gros, où l'on peut extraire une fonction next().

Le plus simple (en attendant les coroutines) est d'utiliser une fonction de rappel. yield visit(n, a) devient callback(visit(n, a)).
Niveau utilisation, le code python for n in f(params...): print (n) devient f(params..., [](auto n){ std::cout << n; }); en c++.

[Seabirds]

Transformer ce truc en itérateur va être terrible. Les itérateurs sont bien pour les algos qui n'utilisent qu'un seul yield, en gros, où l'on peut extraire une fonction next().

Heureux de voir que mon intuition était correcte sur la difficulté à faire une fonction next() dans ce contexte
Je me renseigne sur les callback, merci encore !

[JolyLoic]

Si tu fais du code pour un compilateur particulier, tu peux regarder s'il implémente les coroutines. Sinon, il y a des bibliothèques pour simuler ça, je ne sais pas quel est leur niveau de facilité d'utilisation ou de performance. Par exemple, il y a boost.coroutine.

[Seabirds]

Après lectures et tutoriels sur les coroutines, j'ai choisi de mettre momentanément de côté cette stratégie des générateurs pour implémenter rapidement la solution bourrine de tout stocker en mémoire (deadline iz coming... )
Je clos le sujet et publierai le code dès que j'aurais ajouté les routines à l'algo
Merci à tous pour vos réponses !!!