Discussion :

[méphistopheles]

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]

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]

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]

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]

(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

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]

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).