lu,

Dans ma class A<T> je voudrais deux méthode f. Une qui marche avec des T et une autre avec des T*. Comment faire ?

++

godrik@skynet-ubuntu:tmp$ cat foo.cpp

1. include<iostream>

template<class T>
class A
{
public:
void f(T t){std::cout<<"T"<<std::endl;}
void f(T* t){std::cout<<"T*"<<std::endl;}
};

int main()
{
int toto;
A<int> a;
a.f(toto);
a.f(&toto);
return 0;
}
godrik@skynet-ubuntu:tmp$ make foo
g++ foo.cpp -o foo
godrik@skynet-ubuntu:tmp$ ./foo
T
T*

et voila

C'est pas une spécialisation ça. Moi je veux une fonction différente quand le type en parametre est un pointeur.

Par exemple :
Fonction de comparaison de base :
<syntaxe obscure> bool <syntaxe obscure>::f()
{
return a == b;
}

Qui si a et b sont des pointeurs et remplacée par :
<syntaxe obscure> bool <syntaxe obscure>::f()
{
return *a == *b;
}

Plus simple,

Dans ma classe A<T> je veux qu'une méthode f particulière soit appelée quand T=int. Comment je fais ?

template<class T> class A
{
public:
T* f() {return new T;}
};

Et si veux spécialiser juste f et non pas toute la classe A, tu fait :

template<> int* A<int>::f() { return new int;}