Discussion :

[Davidbrcz]

Bonjour à tous.
Je pense que le titre parle de lui même (), voici donc le code:

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
 
#include <vector>
#include <iostream>
 
class Foo{
public:
    template<typename T> static T plop(T val) 
    {
	return val;
    }
 
    template <class T, template <typename,typename=std::allocator<T> > class C> 
    static C<T> plop(const C<T>& val)
    { 
	std::cout<<"template conteneur"<<std::endl;   
	return std::vector<T>(1, val[1]);
    }
 
};
 
 
//Plante
template <class T> std::vector<T> Foo::plop(const std::vector<T>& val) 
{
    return std::vector<T>(1, val[1]);
}
 
template <> int Foo::plop(int val)
{
    return val*10;
}
 
int main(int argc, char const *argv[])
{
 
    std::cout<<Foo::plop(std::vector<std::string>(3,"Hi world"))[0]<<std::endl;
    std::cout<<Foo::plop("hello")<<std::endl;
    std::cout<<Foo::plop(42)<<std::endl;
    return 0;
}

J'ai l'erreur suivante

b.cpp:53: erreur: prototype for ‘std::vector<T, std::allocator<_Tp1> > Foo::plop(const std::vector<T, std::allocator<_Tp1> >&)’ does not match any in class ‘Foo’
b.cpp:47: erreur: candidates are: template<class T, template<class, class> class C> static C<T, std::allocator<_Tp1> > Foo::plop(const C<T, std::allocator<_Tp1> >&)
b.cpp:43: erreur: template<class T> static T Foo::plop(T)

A la vue de la première ligne, j'ai l'impression qu'il prend la ligne qui plante comme la définition d'une nouvelle fonction et non comme la spécialisation d'une fonction déjà existante. Une idée de comment résoudre ca ?

Je souhaiterai garder les fonctions membres templates pour garder la déduction automatique du type (même si on peut contourner ce problème avec une fonction membre libre qui est là la base d'une autre solution)
Merci beaucoup.

[Goten]

J'ai dans la tête qu'une spécialisation partielle de fonctions membres est impossible, mais j'y mettrais pas ma main au feu. Faut que je ressorte le bouquin sur les templates.

[Klaim]

Effectivement c'est impossible, c'est ce qu'on appelle une specialisation partielle de classe template.

Tu peux spécialiser la classe entièrement, tu peux spécialiser une fonction template entièrement (qu'elle soi membre ou pas) mais tu ne peux pas spécialiser juste une fonction membre d'une classe template (sauf si la dite fonction est template elle même).

[Davidbrcz]

sauf si la dite fonction est template elle même

C'est le cas ici, fonction membre template dans une classe "normale" (pas template). Ou alors on ne donne pas le même sens aux mots et c'est génant

[Klaim]

Je voulais dire qu'a ce moment là tu peux spécialiser la fonction pour les paramettres template de la fonction, mais pas pour ceux de la classe.

Mais effectivement ici il n'y a que ta fonction membre qui est template.
(tiens ça compile pas sous Vc9, il trouve pas T dans la déclaration...)


Après plusieures tentative je n'arrive pas bien a résoudre ton problème, visiblement le paramettre optionel de vector rends la detection de la spécialisation ambigue...

Le principal problème en fait c'est le fait qu'il y ait deux declaration de plop, la première étant une version plus abstraite de la seconde.
Pour résoudre ça rapidement j'ai juste ajouté un s a la seconde implémentation voir, mais il y a toujours un problème de detection.

J'ai essayé ç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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
#include <vector>
#include <iostream>
 
class Foo{
public:
	template<typename T> static T plop(T val) 
	{
		return val;
	}
 
	template <typename T, template <typename, typename> class C, typename A > 
	static C<T,A> plops(const C<T, A >& val)
	{ 
		std::cout<<"template conteneur"<<std::endl;   
		return C<T,A>(1, val[1]);
	}
 
};
 
 
//Plante
template <class T, typename A =std::allocator<T> >
std::vector<T, A> Foo::plops(const std::vector<T, A>& val) 
{
	return std::vector<T, A>(1, val[1]);
}
 
template <> int Foo::plop(int val)
{
	return val*10;
}
 
int main(int argc, char const *argv[])
{
 
	std::cout<<Foo::plop(std::vector<std::string>(3,"Hi world"))[0]<<std::endl;
	std::cout<<Foo::plop("hello")<<std::endl;
	std::cout<<Foo::plop(42)<<std::endl;
	return 0;
}

Mais j'ai l'erreur :

Code :

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

1
2
3
4
5
6
 
1>e:\tests\test_templatememberfunctionspecialization\main.cpp(27) : error C2244: 'Foo::plops' : unable to match function definition to an existing declaration
1>        definition
1>        'std::vector<_Ty,_Alloc> Foo::plops(const std::vector<_Ty,_Alloc> &)'
1>        existing declarations
1>        'C<T,A> Foo::plops(const C<T,A> &)'

Je ne comprends pas bien ou est le problème, vu que les deux signatures me semblent similaires...

[3DArchi]

Salut,
Les spécialisations partielles de fonctions templates n'existent pas il me semble. Ce sont des surcharges - la différence étant que tu dois la déclarer dans la classe :

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
class Foo{
public:
    template<typename T> static T plop(T val)
    {
	return val;
    }
 
    template <class T, template <typename,typename=std::allocator<T> > class C>
    static C<T> plop(const C<T>& val)
    {
	std::cout<<"template conteneur"<<std::endl;
	return std::vector<T>(1, val[1]);
    }
    template <class T>
    static std::vector<T> plop(const std::vector<T>& val)
    {
        return std::vector<T>(1, val[1]);
    }
};

[Goten]

Ah mais oui voilà j'avais mal lu. Je confonds toujours c'est la spécialisation partielle ou l'argument template par défaut dans une fonction template qui est impossible ? (voir les deux? :') )


edit : je viens de vérifier les deux sont interdits. (default template argument et spécialisation partielle de fonction template)

[Davidbrcz]

Ok, merci beaucoup, je passe le sujet en résolu.

[koala01]

Salut,

La spécialisation partielle d'une fonction template étant interdite, pourquoi ne pas, tout simplement, créer un foncteur template qui, lui, pourra être partiellement (ou completement) spécialisé

Le seul bémol à mettre étant que... les différentes implémentations de ce foncteur devront prendre place directement dans la définition de la classe dans laquelle il est imbriqué

Mais cela donnerait un résultat fort proche de

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
class MaClass
{
    template <typename T>
    sturct Foncteur
    {
        /* blabla*/
    }; 
    template <>
    struct Foncteur<int>
    {
        /*blabla*/ 
    };
    template <typename T, typename U>
    struct AutreFoncteur
    {
    };
    template <typename T>
    struct AutreFoncteur <T, int>
    {
    };
};

[Davidbrcz]

C'est la 1er solution que j'évoquais dans mon 1er message, le tout couplé avec une fonction membre libre pour bénéficier de la déduction automatique des types.

Merci à tous