Discussion :

[vikki]

Bonjour à tous,

J'ai un petit problème en utilisant la spécialisation partielle des template (si ca s'appelle bien comme ca). J'ai une bête fonction templatisée :

Code :

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

1
2
3
4
5
6
 
template <class Container,class Functor, class Flag >
void inspect( Container & x, Functor & fun ) 
{ 
       //fait un truc
}

et j'aimerais la spécialiser en fonction du paramètre template Flag. J'ai tenté d'ajouter ceci:

Code :

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

1
2
3
4
5
6
7
8
 
struct suppress;
 
template <class Container,class Functor>
void inspect<Container,Functor,suppress>( Container & x, Functor & fun ) 
{
       //fait un autre truc 
}

L'erreur (sous Visual) est la suivante:
"error C2768: 'inspect' : illegal use of explicit template arguments"
Quelqu'un connaitrait-il la syntaxe à employer?
Merci d'avance

[Jean-Marc.Bourguet]

Pas tres clair le message, je suppose qu'il est du au fait qu'on ne peut pas specialiser partiellement les fonctions templates.

[vikki]

Merci pour la reponse si rapide!
Bon, comme tu le dis, c'est peut-etre pas autorisé au final. Mais vu qu'il existe la spécialisation de fonctions template et la specialisation partielle de classes, je me suis dis "Pourquoi pas la specialisation partielle de fonctions template?".
Je laisse le post ouvert, au cas où un developpeur de chez Microsoft viendrait jeter un coup d'oeil et repondrait

[vikki]

Autant pour moi, avec google et de meilleurs mots clés, il s'avers que cela n'existe pas du tout. Je vais filouter avec des classes template partiellement specialisées alors.

[vikki]

Bon, pour ceux que ca interesse, j'ai trouvé une maniere de contourner le probleme. A la base, je voulais faire de la specialisation partielle de fonction template :

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
 
struct suppress;
struct merge;
struct classif;
struct for_each;
 
template <class Container, class Functor, class Flag>
void inspect( Container & x, Functor & fun )
{
	//fait un truc
}
 
template <class Container, class Functor>
void inspect<Container, Functor, suppress> ( Container & x, Functor & fun )
{
	//fait un autre truc
}
 
template <class Container, class Functor>
void inspect<Container, Functor, merge> ( Container & x, Functor & fun )
{
	//fait encore un autre truc
}
 
//etc...
 
 
//et la fonction generique que j'appelle:
template <class Container, class Functor>
void inspect_generic ( Container & x, Functor & fun )
{
	inspect<Container,Functor, Functor::flag_iter_process>( x, fun);
}

Le but etant de parcourir le container "x" en applicant le foncteur "fun". Or, la maniere de parcourir le container (generalement une liste) varie en fonction du foncteur utilisé. C'est pour cela que mes foncteurs definissent tous un type "flag_iter_process" qui est un simple typedef sur mes structures "suppress", "merge" et compagnies. Cela m'aurait permis d'appeler la fonction "inspect_generic " de cette maniere: inspect_generic ( ma_list, mon_foncteur)" en etant sûr que la methode de parcours de la liste soit bien adaptée au foncteur utilisé.

Ma methode de remplacement est la suivante : je créé une classe doublement template contenant une fonction static template simple que je vais specialiser. Cela donne:

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
 
template <class Container, class Functor>
class Inspect
{
public:
 
 
	template< class Flag >
	static void inspect_container(Container & x, Functor & fun)
	{}
 
	template<>
	static void inspect_container<suppress>(Container & x, Functor & fun)
	{
		//fait un truc	
             }
 
	template<>
	static void inspect_container<merge>(Container & x, Functor & fun)
	{
		//fait un autre truc
	}
 
	template<>
	static void inspect_container<classif>(Container & x, Functor & fun)
	{
		//encore un autre truc
	}
 
	//etc...
};
 
 
//la fonction generique à appeler
template <class Container,class Functor>
void inspect( Container & x, Functor & fun ) 
{ 
	Inspect<Container,Functor>::inspect_container<Functor::flag_iter_process>( x, fun );
}

En fait, je délègue les deux premiers arguments template à la classe pour pouvoir ensuite specialiser ma fonction. Et ca marche du feu de Dieu!!!

[Alp]

C'est effectivement LA méthode de référence.

Elle est donné dans la FAQ il me semble

[Jean-Marc.Bourguet]

Merci pour la reponse si rapide!
Bon, comme tu le dis, c'est peut-etre pas autorisé au final.

Je n'ai pas ete clair. Je suis certain qu'on ne peut pas specialiser partiellement les fonctions.

Mais vu qu'il existe la spécialisation de fonctions template et la specialisation partielle de classes, je me suis dis "Pourquoi pas la specialisation partielle de fonctions template?".

J'ai rien vu dans D&E qui concerne le specialisation partielle en general, sans parler de leur interdiction pour les fonctions.