[Metaprogramation]Boucle for template (très) générique

**méphistopheles** · 16/07/2010, 19h08

Bonjour.

J'essaye (pour le fun ) de programmer une boucle for template (très) générique qui prendrait en paramètre un foncteur nullaire mais avec un paramètre template et le fairait itérer sur un certains champ.

L'implémentation que j'ai essayé de faire donne ça:

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
  template < class template<size_t>Operation,size_t End,int Step=1,size_t Start=0>
  struct ForLoop
  {
    inline void operator()()
    {
      Operation<Start>();
      ForLoop<Operation,Start+Step,Step>();
    }
  };
  template <class template<size_t>Operation, size_t End,int Step>
  struct ForLoop<Operation,End,Step,End>
  {
    inline void operator()()
    {}
  };

l'idée étant d'appeler la fonction comme suit:

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
20
 
//peut-être rajouter une couche template pour Maclasse, et le vector, mais bon :p
  template <Maclasse Value, std::vector<Maclasse> Var>
  struct SetToVal //un exemple de foncteur
  {
    template <size_t Index>
    struct at
    {
      inline void operator()() const
      {
        Var.at(Index) = Value;
      }
    };
  };
 
int main()
{
  std::vector<MaClasse> B(50);
  ForLoop< SetToVal< Maclasse(), B>::at, 50>();
}

Le problème étant, bien entendu, que cela ne compile pas, notamment par-ce que dans

Code :

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

 template < class template<size_t>Operation,size_t End,int Step=1,size_t Start=0>

,une syntaxe du type

Code :

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

class template<size_t>Operation

ne marche pas car il ne prend pas en compte size_t et attend une classe et non une constante...

Du coup, je suis bien eu

Évidemment, je pourrais utiliser des foncteurs inlines unaire à la place, mais pourquoi faire simple quand on peut faire compliqué hein ?

De plus, j'aimerais (encore plus alors que ça ne marche pas) généraliser et avoir un type évalué template (à la place du size_t) et un step qui serait un opérateur évalué en compile time

(je délire je crois).

donc la question est : est-ce possible (et si oui jusqu'a quel point, je ne crois pas au coup du step). et surtout comment ?

Bon, je vous laisse à mes délire de codeur du soir.

Merci

**Goten** · 16/07/2010, 19h12

Quelque chose comme ça :

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
20
21
22
 
template <size_t I, size_t M, size_t INC = 1>
struct for_
{
    template <typename F>
	static void apply(const F& f)
	{
	    f();	    
	    for_<I+INC, M, INC>::apply(f);
	}   
 
};
 
template <size_t M, size_t INC>
struct for_<M,M,INC>
{
    template <typename F>
	static void apply(const F& f)
	{
	   f();
	}
};

?

**méphistopheles** · 16/07/2010, 19h28

Envoyé par Goten

Quelque chose comme ça :

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
20
21
22
 
template <size_t I, size_t M, size_t INC = 1>
struct for_
{
    template <typename F>
	static void apply(const F& f)
	{
	    f();	    
	    for_<I+INC, M, INC>::apply(f);
	}   
 
};
 
template <size_t M, size_t INC>
struct for_<M,M,INC>
{
    template <typename F>
	static void apply(const F& f)
	{
	   f();
	}
};

?

non, car là, on ne peut passer d'index à f... et j'aimerais le lui passer en template (pas en paramètre "normal")

**Goten** · 16/07/2010, 19h56

Tu peux pas faire ce que tu veux (et je vois pas pourquoi tu le passerais pas en paramètre de fonction...).

Mais j'avoue que c'est un poil confus ce que tu veux donc j'ai peut être mal saisi.

**méphistopheles** · 16/07/2010, 20h27

Envoyé par Goten

(et je vois pas pourquoi tu le passerais pas en paramètre de fonction...).

L'idée est de pouvoir l'utiliser comme ce que c'est c'est à dire un paramètre template et non un argument. par exemple, supposons que je veuille assigner à chaque membre d'un tableau la valeur de la factorielle correspondant à l'index:

il me suffirait alors d'écrire:

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
20
21
22
23
template<class Type,unsigned int Val>
struct Factorielle
{
  const static Type Value=Factorielle<Type, Val-1>;
}
template<class Type>
struct Factorielle<Type, 0>
{
  const static Type =1;
}
 
template < std::vector<MaClasse> Var>
struct SetToFact //un exemple de foncteur
{
  template <size_t Index>
  struct at
  {
    inline void operator()() const
    {
      Var.at(Index) = Factorielle<MaClasse,Index>::Value;
    }
  };
};

et initialiser mon tableau avec:

Code :

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

1
2
3
4
5
int main()
{
  std::vector<MaClasse> B(50);
  ForLoop< SetToFact< Maclasse(), B>::at, 50>();
}

Alors qu'obtenir ce genre de comportement est impossible à l'aide d'un foncteur puisque dés lors qu'il est passé en paramètre, l'index n'est plus template :s

Envoyé par Goten

Mais j'avoue que c'est un poil confus ce que tu veux donc j'ai peut être mal saisi.

Désolé, ce n'est pas tres simple non plus

je fais du mieux que je peux.

**Flob90** · 16/07/2010, 20h44

Quelque chose comme ca :

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
20
21
22
23
24
25
 
template
<
	template<size_t> class Operation,
	size_t End,
	int Step=1,
	size_t Start=0
>
struct ForLoop
{
	inline void operator()()
	{
		Operation<Start>();
		ForLoop<Operation,End,Step,Start+Step>();
	}
};
 
template
<
	template<size_t> class Operation,
	size_t End,
	int Step
>
struct ForLoop<Operation,End,Step,End>
{ inline void operator()() {}; };

J'ai pas testé si ca marchais, mais en tout cas ca compile.

template<size_t> class Operation est la syntaxe pour les template template parameter, c'est à dire les paramètre template qui sont des class template. Inutile de nommer les (second) paramètres templates, ils sont inutiles. Dans ton cas c'est size_t mais ca pourrait être template<class> class Operation slon le cas. (cf faq template comeau pour des détail, et MC++D pour une utilisation).

**méphistopheles** · 16/07/2010, 21h07

Envoyé par Flob90

Quelque chose comme ca :

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
20
21
22
23
24
25
 
template
<
	template<size_t> class Operation,
	size_t End,
	int Step=1,
	size_t Start=0
>
struct ForLoop
{
	inline void operator()()
	{
		Operation<Start>();
		ForLoop<Operation,End,Step,Start+Step>();
	}
};
 
template
<
	template<size_t> class Operation,
	size_t End,
	int Step
>
struct ForLoop<Operation,End,Step,End>
{ inline void operator()() {}; };

Si je déroule un peu mon code, je ne vois pas trop la différence

edit: ha si, le end que je passe pas en paramètre, mais je l'avais corrigé dans la version que j'ai testée. Et bravo si vous avez réussi à lire ce message sans selectionner

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
20
21
22
23
24
25
26
27
28
29
30
31
32
template 
< 
  class template<size_t>Operation,
  size_t End,
  int Step=1,
  size_t Start=0
>
struct ForLoop
{
  inline void operator()()
  {
    Operation<Start>();
    ForLoop<Operation,Start+Step,Step>();
  }
};
template 
<
  class template<size_t>Operation,
  size_t End,
  int Step
>
struct ForLoop
<
  Operation,
  End,
  Step,
  End
>
{
 inline void operator()()
  {}
};

Et chez moi ça ne compilait pas car il voulait une classe et pas un paramètre const à la place de l'index d'Operation<Index>

Je testerai ton code demain....

Envoyé par Flob90

template<size_t> class Operation est la syntaxe pour les template template parameter, c'est à dire les paramètre template qui sont des class template. Inutile de nommer les (second) paramètres templates, ils sont inutiles. Dans ton cas c'est size_t mais ca pourrait être template<class> class Operation slon le cas. (cf faq template comeau pour des détail, et MC++D pour une utilisation).

c'est bien le problème, il me semble qu'une value n'est pas une classe pour le compilo

... et donc que je ne peux pas passer un index...

**Flob90** · 16/07/2010, 21h12

Tu ne vois pas la différence ? Tu as mis class template<size_t> Operation, c'est pas pareil que template<size_t> class Operation. Et j'ai corrigé ton appel à ForLoop, erreur d'inattention je suppose.

**méphistopheles** · 16/07/2010, 21h16

Envoyé par Flob90

Tu ne vois pas la différence ? Tu as mis class template<size_t> Operation, c'est pas pareil que template<size_t> class Operation. Et j'ai corrigé ton appel à ForLoop, erreur d'inattention je suppose.

Heu en fait, c'est également un mauvais copié collé, par-ce qu'en désespoir de cause, j'avais testé tout un tas de truc sans enregistrer de version intermédiaires et je suis revanu là dessus à coups de ctrl +Z donc y'a du brouillon (mais normalement, il me semble avoir testé la version que tu propose... ou alors j'ai la mémoire qui va plus.)

Je vous donnerais les résultats des tests demain

**Flob90** · 16/07/2010, 21h30

Le code que je t'ai donné doit marcher, apr contre c'est ton exemple avec le factorielle qui risque de ne pas marcher !

Je ne sais pas ce que doit faire factorielle, mais en tant que telle elle ne fait rien qui ressemble à une factorielle classique ! Pour le moment ton code de factorielle est équivalent à ca :

Code :

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

1
2
3
4
 
template<class Type,unsigned int Val>
struct Factorielle
{ const static Type Value = 1; }

Je ne pense pas que se soit le but !

Et le problème de compilation vient de ca :

Code :

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

template < std::vector<MaClasse> Var>

On ne peut passer que des valeurs entières en parmètre template, donc pas de std::vector<>

Voila un exemple qui compile et fonctionne. (Il fallait aussi doubler les parenthèses sur tes foncteur, sinon ca ne fait que créer un objet):

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
template
<
	template<size_t> class Operation,
	size_t End,
	size_t Step=1,
	size_t Start=0
>
struct ForLoop
{
	inline void operator()()
	{
		Operation<Start>()();
		ForLoop<Operation,End,Step,Start+Step>()();
	}
};
 
template
<
	template<size_t> class Operation,
	size_t End,
	size_t Step
>
struct ForLoop<Operation,End,Step,End>
{ inline void operator()() {}; };
 
template<size_t N>
struct Fact
{  enum { value = N * Fact<N-1>::value }; };
 
template<>
struct Fact<0>
{ enum { value = 1 }; };
 
std::vector<size_t>* global(std::vector<size_t>* p = NULL)
{ 
	static std::vector<size_t>* v = p;
	if(p != NULL) v = p;
	return v;
}
 
template <size_t Index>
struct at
{
	inline void operator()() const
	{ global()->at(Index) = Fact<Index>::value; }
};
 
int main() 
{
	std::vector<size_t> b(50);
	global(&b);
  	ForLoop<at, 50>()();
	std::cout << b[5];
	system("PAUSE");
	return 0;
}

Bon, je passe par une global (caché dans une fonction), mais j'ai pas trouvé d'autre moyen pour rendre cette valeur commune à tout les foncteur template at (et j'y ai pas réfléchi plus que ca).

**méphistopheles** · 17/07/2010, 08h52

Envoyé par Flob90

Le code que je t'ai donné doit marcher, apr contre c'est ton exemple avec le factorielle qui risque de ne pas marcher !

Oui effetcivement, ça marche.

Envoyé par Flob90

Je ne sais pas ce que doit faire factorielle, mais en tant que telle elle ne fait rien qui ressemble à une factorielle classique !

Oui effectivement, j'étais relativement fatigué hier soir. le code que je voulais écrire est évidemment:

Code :

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

1
2
3
4
5
6
7
template<size_t N>
struct Fact
{  const static size_t value = N * Fact<N-1>::value ; };
 
template<>
struct Fact<0>
{ const static  size_t value = 1 ; };

Malheureusement, le compilo n'accepte rien d'autre que des ints en template (ça vas changer avec le C++1x ?)

Envoyé par Flob90

Voila un exemple qui compile et fonctionne. (Il fallait aussi doubler les parenthèses sur tes foncteur, sinon ca ne fait que créer un objet):
Bon, je passe par une global (caché dans une fonction), mais j'ai pas trouvé d'autre moyen pour rendre cette valeur commune à tout les foncteur template at (et j'y ai pas réfléchi plus que ca).

J'ai pas trouvé non plus. passer un pointeur par template ne marche pas

et une expression non constante non plus... par contre, il est possible de multiplier les différentes instances de globales et de les passer via une classe, mais j'ai rien trouvé de mieux.

merci en tout cas, je ne pensais pas en arriver là

**JolyLoic** · 17/07/2010, 12h07

Envoyé par méphistopheles

Malheureusement, le compilo n'accepte rien d'autre que des ints en template (ça vas changer avec le C++1x ?)

Le brouillon actuel de la norme dit (et je crois que c'était déjà ça en C++98) :

Code :

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

1
2
3
4
5
 
A non-type template-parameter shall have one of the following (optionally cv-qualified) types:
— integral or enumeration type,
— pointer to object or pointer to function,
— lvalue reference to object

Par contre, ce qui risque de changer pour ce genre de choses, ce sont les constexpr, qui permettront par exemple d'écrire la fonction factorielle résolue à la compilation sans passer par des astuces à base de templates.

**Joel F** · 17/07/2010, 14h12

il est de bon aloi de passer par des Integral Constant (std::integral_c ou mpl::int_ etc consors) plutot que des parametres template entiers. Ca evite les blagues (et accessoirement rend le truc plus générique).

**méphistopheles** · 17/07/2010, 18h12

Envoyé par Joel F

il est de bon aloi de passer par des Integral Constant (std::integral_c ou mpl::int_ etc consors) plutot que des parametres template entiers. Ca evite les blagues (et accessoirement rend le truc plus générique).

C'est une feature TR1 ?

**Joel F** · 17/07/2010, 18h52

Oui et c'ets dans mpl depuis lurette

**Goten** · 17/07/2010, 19h10

IIRC c'est 0x non pas tr1.

edit : En fait j'avais tord, c'est bien dispo depuis TR1.

gl · 18/07/2010, 18h27

Envoyé par Joel F

il est de bon aloi de passer par des Integral Constant (std::integral_c ou mpl::int_ etc consors) plutot que des parametres template entiers. Ca evite les blagues (et accessoirement rend le truc plus générique).

Te serait-il possible de développer un peu plus ? N'étant pas toujours à l'aise avec les subtilités des templates (mais je me soigne), je ne vois pas à quelles blagues tu fais allusions?

**Goten** · 18/07/2010, 19h25

Parce que avoir des paramètres template hétérogénes (valeurs mixées avec type) ça fait pas joli ménage avec les metafonction et plus particulièrement avec les lambda.