Discussion :

[MatRem]

A priori ce que je vais demander fonctionne avec g++, mais je me demande si c'est bien légal, puisque je ne l'ai vu expliqué nul part.

Soit un model de classe C<T> possédant des fonctions membres, est il possible de spécialiser, certaines de ses fonctions membres, seulement dans leur définition?

Un petit exemple descriptif:

Code C.h :

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

1
2
3
4
5
6
7
template <typename T>
class C
{
   void test();
}
 
#include "C.tpp"

Code C.tpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<typename T>
void C<T>::test()
{
   ...
}
template<>
void C<double>::test()
{
   ...
}
template<>
void C<float>::test()
{
   ...
}

Ainsi avec une utilisation:

Code :

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

1
2
3
C<double> t;
//t::test(); edité
t.test();

ce sera la spécialisation C<double>::test qui sera utilisée.

Ce que j'ai compris dans ce genre de cas, c'est qu'il faut déclarer entièrement les models C<double> et C<float>. Est-ce vraiment ce que dit la norme?

[MatRem]

Ça ne choque personne ce que j'ai écrit?
Ça doit être correct alors .

[David Fleury]

Code :

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

1
2
3
4
5
 
C<double> t;
t::test(); // déclenche une erreur sous gcc 4.1
// t n'est pas une classe ni une ni un namespace
// il faudrait t.test();

Tu peux spécialiser un seul membre mais tu ne peux plus ensuite spécialiser la classe complète.

Code :

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

1
2
3
4
 
template<>
classe C<double> {
};

devrait produire une erreur.

Je ne suis pas trop sûr de comprendre l'intéret de spécialiser une seule méthode.

[MatRem]

Oui excuse moi je voulais mettre un ., j'ai été un peu trop vite. (j'édite mon premier post).

L'intérêt par exemple (il est lié à OpenGL):
- J'ai une classe Couleur<T> qui contient les composantes r, v, b, a. Elle contient aussi une fonction glCall(), qui permet de faire l'appel OpenGL correspondant ;
- la classe sera utilisée avec int, double ou float ;
- j'aurais voulu réduire les possibilités du type template, mais ce n'est pas encore possible ;
- donc la fonction glCall n'est pas définit par défaut ;
- par contre, elle est spécialisée pour les 3 types précédents, pour utiliser glColor4d*, glColor4f*, ou glColor4i* .

Je n'ai donc pas besoin de spécialiser toute la classe.

Voilà mon exemple, peut être y'a t il moyen de faire mieux...

[David Fleury]

- j'aurais voulu réduire les possibilités du type template, mais ce n'est pas encore possible ;

pour limiter les spécialisations possibles de Couleur<T> ?

Si oui, tu dois pouvoir le faire en t'aidant des erreurs de link.

Pour une meilleure solution, je ne sais pas. J'aurais tout simplement spécialisé la classse.

[Laurent Gomila]

Une autre solution :

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
template <typename T>
class Couleur
{
public :
 
    void glCall() {Private_glCall(r, v, b, a);}
 
private :
 
    T r, v, b, a;
};
 
void Private_glCall(int r, int v, int b, int a)             {glColor4i(r, v, b, a);}
void Private_glCall(float r, float v, float b, float a)     {glColor4f(r, v, b, a);}
void Private_glCall(double r, double v, double b, double a) {glColor4d(r, v, b, a);}

Au passage, ça génèrera une erreur si T n'est pas un type convertible en int, float ou double (ce qui n'est déjà pas mal). Tant que tu y es tu devrais aussi gérer les autres types (unsigned char par exemple est le plus utilisé).

Simple curiosité : tu laisses le choix du type de composantes pour quelles raisons ? D'habitude en programmation 3D, sauf besoin spécifique, on choisit une représentation interne unique pour les couleurs, et on gère les conversions vers / depuis d'autres types.