Discussion :

[Charlemagne]

Salut
Est-ce que quelqu'un voit comment faire une boucle "for" en meta-programmation sur un intervalle constant?
Il faudrait que cette boucle se déroule complètement pour le compilo et que l'on ait accès au numéro d'itération dans la boucle.

Pour l'exemple du factoriel de 10, quelque chose qui ressemblerait plus ou moins à ceci:

Code :

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

1
2
3
4
5
fact*=1
meta_for<1,10>
{
  fact*=I;
}

Ou peut-être bien avec un foncteur, du genre:

Code :

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

1
2
3
4
5
6
7
8
struct fact
{
  int x;
  fact() :x(1) {};
  void operator() (int i) { x=i*x;}
};
 
meta_for<1,10>(fact())

[loufoque]

La méta-programmation c'est du fonctionnel pur.
Faire une boucle for ça n'a pas de sens.

Après, tu peux faire un fold/accumulate...

Le deuxième truc c'est juste une boucle déroulée, pas de la méta-programmation.

[Luc Hermitte]

C'est comme en prolog.
Tu pars d'un bout jusqu'à ce que tu puisses unifier (voca?) avec l'autre bout.

Tu définis donc ta règle générale de N en fonction de N-1, et la règle finale pour 1.

PS: l'exemple de la factorielle doit être le plus répandu dans la littérature relative à la méta-prog.

[Charlemagne]

C'est peut-être pas de la "meta-programmation", quoi qu'il en soit est-il possible de dérouler une boucle avec une programmation de ce genre. et comment?

L'exemple de la factorielle est peut-être mal choisi.
Ce que je veux c'est bien un moyen de dérouler une boucle "for", pour en accélérer le calcul.
C'est pour mettre dans une fonction qui recoit un paramètre constant par template.

[white_tentacle]

-funroll-loops ? (de mémoire, sous gcc).

Certes, ce n'est pas de la meta-programmation, mais si tu en es à ce niveau d'optimisation, commence peut-être par jouer avec les paramètres du compilo, non ?

[Luc Hermitte]

Je te renvoie aux fondamentaux: http://www.oonumerics.org/blitz/papers/
Tu trouveras des liens vers les articles de Todd Veldhuizen. Dans mes souvenirs il y avait des explications sur comment dérouler les boucles.

[Alp]

Il y aussi ça (Merci Laurent Gomila) :
http://loulou.developpez.com/tutoriels/cpp/metaprog/

[Alp]

Ah et au passage, la lecture de C++ Template Metaprogramming ne peut être que bénéfique pour toi.
C'est l'ouvrage de référence, avec C++ Templates : The Complete Guide (de Verdhuizen entre autres justement), pour tout ce qui se rapproche à la métaprogr en C++.

[loufoque]

Dérouler une boucle c'est un peu trivial...

Code :

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
template<size_t I, size_t M, size_t INC = 1, typename Enable = void>
struct for_unrolled
{
	template<typename F>
	static inline void apply(const F& f)
	{
		f(I);
		for_unrolled<I+INC, M, INC>::apply(f);
	}
};
 
template<size_t I, size_t M, size_t INC>
struct for_unrolled<I, M, INC, typename boost::enable_if_c<I >= M>::type>
{
	template<typename F>
	static inline void apply(const F& f)
	{
	}
};

[3DArchi]

J'avais proposée une solution de ce genre il y a quelques temps sur une autre question : cf ici (dans tous le fouillis, c'est dec2oct2dc) .
Ca revient (en un peu plus brouillon) à ce que te proposes loufoque : un générique pour le parcours et une spécialisation partielle pour l'arrêt.

[Charlemagne]

Merci à tous, ça répond à ma question