Discussion :

[Davidbrcz]

Bonjour à tous.

J'ai le code d'une bibliothèque dont le code (qui en lui même n'est pas très dur) est extrèmement long car chaque module dispose de 6 surcharges pour gérer les fonctions possédant jusqu'a 6 paramètres.

Exemple:

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
 
// For nullary through sestiary(6-ary) function objects
template<typename Ret> inline
Ile<Call_0<Ret(*)(void)> > call(Ret(* f)(void)) {
	return Call_0<Ret(*)(void)>(f);
}
 
template<typename Ret, typename A1, typename P1> inline
Ile<Call_1<Ret(*)(P1),A1> > call(Ret(* f)(P1), const A1& a1) {
	return Call_1<Ret(*)(P1),A1>(f,a1);
}
 
template<typename Ret, typename P1, typename P2, typename A1, typename A2> inline
Ile<Call_2<Ret(*)(P1,P2),A1,A2> > call(Ret(* f)(P1,P2), const A1& a1, const A2& a2) {
	return Call_2<Ret(*)(P1,P2),A1,A2>(f,a1,a2);
}

Et ca va comme ca jusqu'a P6/A6
Je me demandais si on ne pouvait pas factoriser le code à l'aide de boost::preprocessor.

Etant donné que je n'ai jamais travaillé avec cette bibliothèque , est ce que c'est du domaine du faisable ?
Si la réponse est négative, y'a t'il un moyen de le faire avec quelque chose d'autre ?

Merci.
David Côme.

[JolyLoic]

C'est typiquement le genre de choses pour lesquelles boost.pp a été conçu. Une alternative plus performante si tu bosses avec gcc est d'utiliser les variadic templates de c++0x.