Spécialisation partielle de template

Version imprimable

Bonjour tout le monde,
Je bute sur un problème et je ne comprends pas comment le résoudre.

J'essaie de spécialiser un seul de mes typename au niveau de mon template mais je n'y arrive pas:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template <typename A, typename B, typename C> class Test { public: void foo(const B & d) { //fait quelque chose } }; template<typename B, typename C> void Test<int, B, C>::foo(const B & d) { //fait autre chose }
Je suis avec clang (Apple LLVM version 6.0 (clang-600.0.56)), je compile en C++11 et j'obtiens l'erreur de compilation suivante:
Code:

1 2 3 error: nested name specifier 'Test<int, B, C>::' for declaration does not refer into a class, class template or class template partial specialization void Test<int, B, C>::foo(const B & d) ~~~~~~~~~~~~~~~~~^
La logique de mon raisonnement est de pouvoir avoir un autre comportement de fonction si le premier typename A est un int sans à se soucier des autres typenames.

Première question, est-ce possible?
Si oui, qu'est-ce que je fait de mal?

Merci pour tout!

Lu'!

C'est ta classe qui est template, c'est elle que tu dois partiellement spécialiser.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 template <typename A, typename B, typename C> class Test { public: void foo(const B & d) { std::cout<<"most generic foo"<<std::endl; } }; template<typename B, typename C> class Test<int, B, C> { public: void foo(const B & d) { std::cout<<"partially specialized foo"<<std::endl; } };
Sinon, ton compilateur n'a pas connaissance de ce qu'est le type Test<int,B,C>, il est spécialisé mais cette spécialisation n'est pas déclarée.

Si la spécialisation partielle ne concerne que cette fonction, tu peux éventuellement te demander s'il ne faudrait pas virer un paramètre template de la classe et déclarer la fonction comme elle même template dans la classe template.

Super merci beaucoup pour ta réponse qui fonctionne parfaitement... mais on doit redéfinir toutes les méthodes de la classes pour une spécialisation précise.
Dans mon cas précis, je ne peux pas supprimer de paramètre template.

Je me suis donc tourné vers l'utilisation de std::enable_if et de std::is_same.

Voici un exemple un peu plus complexe:

Code:

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
template <typename A, typename B, typename C>
class Test
{
public:
  template <typename T = A>
  typename std::enable_if<!(std::is_same<T, int>::value), void>::type
  fooA(const T & a)
  {
    std::cout << "fooA" << std::endl;
  }
 
  template <typename T = A>
  typename std::enable_if<std::is_same<T, int>::value, void>::type
  fooA(const T & a)
  {
    std::cout << "specialized fooA" << std::endl;
  }
 
  void fooB(const B & b)
  {
    std::cout << "fooB" << std::endl;
  }
  void fooC(const C & c)
  {
    std::cout << "fooC" << std::endl;
  }
};
 
int main(int argc, char **argv)
{
  Test<long, char, char> t1;
  t1.fooA(1l); //fooA 
  t1.fooB('c'); //fooB
  t1.fooC('c'); //fooC
 
  Test<int, char, char> t2;
  t2.fooA(1);  //specialized fooA
  t2.fooB('c'); // fooB
  t2.fooC('c'); // fooC
 
  Test<int, int, int> t3;
  t3.fooA(1); //specialized fooA
  t3.fooB(1); //fooB
  t3.fooC(1); //fooC
}