Discussion :

[3DArchi]

Bonjour,
Je part d'une classe template avec 2 arguments template. Je souhaite spécialiser une des méthodes sur un seul de deux arguments. Echec
Voici mon 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
 
template< class A, class B>
class T
{
public:
   void MaFonction()
   {
      std::cout<<"?,?"<<std::endl;
   }
};
// cette spécialisation fonctionne
template<>
void
T<int,int>::MaFonction()
{
   std::cout<<"int,int"<<std::endl;
}
 
// celle-ci ne compile pas
template<class B>
void
T<int,B>::MaFonction()
{
   std::cout<<"int,?"<<std::endl;
}

Je suis obligé de spécialiser partiellement toute la classe
Le code suivant ne pose pas de problème:

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
 
template< class A, class B>
class T
{
public:
   void MaFonction()
   {
      std::cout<<"?,?"<<std::endl;
   }
};
 
template<class B>
class T<int,B>
{
public:
   void MaFonction()
   {
      std::cout<<"int,?"<<std::endl;
   }
};
 
template<>
class T<int,int>
{
public:
   void MaFonction()
   {
      std::cout<<"int,int"<<std::endl;
   }
};

Je n'ai rien trouvé sur la spécialisation partielle de méthodes. En général, les docs parlent de spécialisation partielle pour les classes et de spécialisation (tout court) pour les méthodes. Une idée?

[yan]

normalement tout depend du compilot.
mais tu peut(normalmen) faire une spécialisation partielle mais dans l'ordre inverse

Code :

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

1
2
3
4
5
6
7
template<class B>
void
T<B,int>::MaFonction()
{
   std::cout<<"?,int"<<std::endl;
}

[3DArchi]

J'ai essayé avec Visual (Express) et avec gcc (sous windows) et les deux refusent la spécialisation telle que donnée par Mongaulois. J'ai peur d'avoir à spécialiser partiellement toute la classe.

[3DArchi]

Merci Mongaulois, mais là tu fais une spécialisation de la classe. La spécialisation partielle de la classe fonctionne même avec le mot clé class. Mon seul problème est de spécialiser uniquement la méthode. Et, là, j'ai bien l'impression que ca n'est pas possible pour une spécialisation partielle.

[yan]

Merci Mongaulois, mais là tu fais une spécialisation de la classe. La spécialisation partielle de la classe fonctionne même avec le mot clé class. Mon seul problème est de spécialiser uniquement la méthode. Et, là, j'ai bien l'impression que ca n'est pas possible pour une spécialisation partielle.

Oui j'ai compris après ton problème dsl.
En cherchant un peu, je n'ai pas trouvé une autre manière que de passer par la class....
Je ne sait pas trop si ça touche tout la class, ou juste ce que tu redéfinie.

[3DArchi]

En cherchant un peu, je n'ai pas trouvé une autre manière que de passer par la class....

Moi non plus... Mais, comme je n'ai trouvé aucun exemple ou info sur une spécialisation partielle de méthode, j'ai tenté la question sur le forum. Les exemples concernent toujours une spécialisation totale d'une méthode ou une spécialisation partielle d'une classe. Il faudrait peu être rajouté un petit mot dans la FAQ (il y a un topic sur la spécialisation).

Je ne sait pas trop si ça touche tout la class, ou juste ce que tu redéfinie.

Là, la réponse est dans la FAQ (http://cpp.developpez.com/faq/cpp/?p...specialisation) : une spécialisation d'une classe t'oblige à tout spécialiser (je fais le mec qui sait mais j'avais posé une question là dessus sur le forum, et spout - http://www.developpez.net/forums/d60...s/#post3601175 - m'a renvoyé là dessus).

[yan]

Apparemment,
les méthodes d'un classe ne peuvent être spécialisé.
Par contre il y as des astuce et utilisant l'héritage :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#include <iostream>
/*base de ta class*/
template< typename A, typename B>
class T_base
{
public:
 
    virtual void MaFonction() =0   ;
 
    void MaFonction2()
   {
      std::cout<<"azeaze"<<std::endl;
   }
};
 
/*class en general*/
template< typename A, typename B>
class T :public T_base<A,B>
{
public:
    void MaFonction()
    {
        std::cout<<"? , ?"<<std::endl;
    }
};
/*cas du ? , int */
template< typename A>
class T<A,int> :public T_base<A,int>
{
public:
    void MaFonction()
    {
        std::cout<<"? , int"<<std::endl;
    }
};
/*cas du int , ? */
template< typename B>
class T<int,B> :public T_base<int,B>
{
public:
    void MaFonction()
    {
        std::cout<<"int , ?"<<std::endl;
    }
};
/*cas du int , int */
template<>
class T<int,int> :public T_base<int,int>
{
public:
    void MaFonction()
    {
        std::cout<<"int , int"<<std::endl;
    }
};
 
int main(int argc, char* argv[])
{
    T<int,int> t;
    t.MaFonction();
    t.MaFonction2();
    T<float,int> t1;
    t1.MaFonction();
    t1.MaFonction2();
    T<int,float> t2;
    t2.MaFonction();
    t2.MaFonction2();
	return 0;
}

[3DArchi]

Apparemment,
les méthodes d'un classe ne peuvent être spécialisé.

La phrase exacte semble plutôt être: les méthodes d'une classe ne peuvent être partiellement spécialisée.

Par contre il y as des astuce et utilisant l'héritage :

Quel est l'intérêt par rapport à la deuxième section code de mon premier post:

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
 
 
template< class A, class B>
class T
{
public:
   void MaFonction()
   {
      std::cout<<"?,?"<<std::endl;
   }
};
 
template<class B>
class T<int,B>
{
public:
   void MaFonction()
   {
      std::cout<<"int,?"<<std::endl;
   }
};
 
template<>
class T<int,int>
{
public:
   void MaFonction()
   {
      std::cout<<"int,int"<<std::endl;
   }
};

[yan]

Lorsque tu spécialise une class, il faut tout redéfinir. Passer par l'héritage te permet de redéfinir que ce dont tu as besoin. Dans mon exemple, void MaFonction2() n'as pas à être redéfinie pour chaque spécialisation. Toi tu n's pas le choix.

Par contre avec le futur C++, y as des chances que se sera beaucoup plus simple

[3DArchi]

Désolé, je n'avais pas vu ta seconde fonction (lecture un peu trop rapide ).
J'ai continué à chercher des infos sur cette spécialisation partielle de méthode d'une classe. Je n'ai pas encore fini de tout dépiauter dans la norme, mais à un moment, j'ai trouvé le paragraphe suivant

The template parameter list of a member of a class template partial specialization shall match the template parameter list of the class template partial specialization. The template argument list of a memeber of class template partial specialization shall match the template argument list of the class template partial specialization. A class template specialization is a distinct template.

J'en déduit que je ne peux faire une spécialisation partielle d'un membre que si j'ai fait une spécialisation partielle de la classe. Ce n'est pas tout à fait ce que disent les deux premières phrases mais cela se comprend à l'aulne de la troisième.