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