Discussion :

[darkman19320]

Bonjour tout le monde,

Je cherche à partir d'une classe qui hérite de plusieurs polices avec la même méthodes:

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
#include <iostream>
 
template<typename PolicyOne, typename PolicyTwo>
class Test : public PolicyOne, public PolicyTwo
{
  void run()
  {
    PolicyOne::run();
    PolicyTwo::run();
  }
};
 
class PolicyA
{
  void run()
  {
    std::cout << "PolicyA" << std::endl;
  }
};
 
class PolicyB
{
  void run()
  {
    std::cout << "PolicyB" << std::endl;
  }
};
 
int main(int argc, char* argv[])
{
  Test<PolicyA, PolicyB> t1;
  t1.run(); // Affiche PolicyA\nPolicyB
  return 0;
}

Je voudrais maintenant "généraliser" un peu ce type de comportement en ayant un nombre "illimité" de polices (ayant toutes le même nom de méthode). J'ai donc pensé au variadic templates avec l'implémentation suivante:

Code :

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

1
2
3
4
5
6
7
8
template<typename... Policies>
class Test : public Policies...
{
   void run()
   {
     //Que mettre ici??? Policies...::run()?
   }
};

Je ne sais pas comment parcourir l'ensemble de mes classes Policies. Peut-on utiliser une lambda fonction?

Merci pour tout!

[white_tentacle]

Je ne sais pas comment parcourir l'ensemble de mes classes Policies. Peut-on utiliser une lambda fonction?

Merci pour tout!

Ça me parait possible avec une classe template PolicyExecutor (qui serait donc « friend » de ta classe Test si run est privée), et une récursion du coup classique sur les politiques.

Quelque chose comme (écrit à la volée, sans garantie):

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<typename T>
struct PolicyExecutor
{
    static void exec(Test& t)
    {
         static_cast<T&>(t).run();
    }
};
 
template<typename T, typename... Args>
struct PolicyExecutor
{
    static void exec(Test& t)
    {
         PolicyExecutor<T>::exec(t);
         PolicyExecutor<Args...>::exec(t);
    }
}

[prgasp77]

Il va falloir procéder par récursion. Quelque chose comme ça (je ne me souviens plus de la syntaxe) :

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 Test<void>
{
    void run() {}
};
 
template<class PolicyHead, class... PolicyTail>
class Test : public PolicyHead, public Test<PolicyTail...>
{
    void run()
    {
         PolicyHead::run();
         Test<PolicyTail...>::run();
    }
};

[darkman19320]

Merci. Grace à vos deux réponses j'ai réussi.

Voici la syntaxe correcte:

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
#include <iostream>
 
class PolicyA
{
public:
	void run()
	{
		std::cout << "PolicyA" << std::endl;
	}
};
 
class PolicyB
{
public:
	void run()
	{
		std::cout << "PolicyB" << std::endl;
	}
};
 
template<typename PolicyHead, typename... PolicyTail>
class Test : public PolicyHead, public Test<PolicyTail...>
{
public:
	void run()
	{
		PolicyHead::run();
		Test<PolicyTail...>::run();
	}
};
 
template<typename Policy>
class Test<Policy>: public Policy
{
public:
	void run()
	{
		Policy::run();
	}
};
 
int main(int argc, char* argv[])
{
	Test<PolicyA, PolicyB, PolicyA, PolicyA, PolicyB> t1;
	t1.run(); // Affiche PolicyA \n PolicyB \n PolicyA \n PolicyA \n PolicyB
	return 0;
}

Bien évidemment, il faut un compilo qui accepte les variadic templates...

[jo_link_noir]

Code :

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

1
2
3
void run() {
    (void)std::initializer_list<int>{(void(static_cast<Policies&>(*this).run()), 1)...};
}

ou s'il n'y a pas d'héritage:

Code :

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

1
2
3
void run() {
    (void)std::initializer_list<int>{(void(Policies::run()), 1)...};
}

[darkman19320]

@jo_link_noir: merci pour ta réponse. J'ai une petite question pourquoi tu as mis des cast void? Je viens de tester sans les casts: le code compile et fonctionne de la même manière.

[prgasp77]

Ce ne sont pas des cast ; ils sont là pour ignorer explicitement les valeurs de retour. Ton objectif est d'appeler les Policies::run() ; et l'astuce trouvée par jo_link_noir passe par la construction d'une std::initialization_list<int> ; objet qui doit être disposé, on le fait donc de manière explicite, améliorant la lisibilité du code et supprimant le warning de compilation (-Wunused-value). Le second est plus subtile, tellement que je ne suis pas sûr de moi : on ignore le résultat de Policies::run() avec l'operator, et on retourne la constante 1 ; à nouveau expliciter la disposition du retour aide à la lisibilité. Qui plus est, si les méthodes run() devaient retourner quelque chose à l'avenir, cette ligne est toujours valable.

Corrigez-moi si je me trompe.