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.

[MatRem]

Merci pour ta suggestion.

Je laisse le choix premièrement parceque en fait j'écris ça sous forme d'une bibliotheque. Donc je pense qu'il est intéressant de laisser choisir l'utilisateur.
Ensuite je me sers de Couleur pour la classe Material. Et pour ses composantes il faut des float.
Hors je penses que l'utilisateur voudrait utiliser autre chose que des float.
Mais je me demande si des float ne suffisent pas. Et il intéressant d'utiliser des doubles? (la c'est plus vraiment une question de c++ )

[Laurent Gomila]

Je laisse le choix premièrement parceque en fait j'écris ça sous forme d'une bibliotheque. Donc je pense qu'il est intéressant de laisser choisir l'utilisateur.

Justement, ce que je te disais c'est qu'on laisse généralement ce choix, mais sous forme de conversions vers / depuis une représentation interne fixée.
De plus l'inconvénient c'est que chaque fonction de ta bibliothèque qui prendra en paramètre une couleur, devra être template.

Et il intéressant d'utiliser des doubles?

En programmation 3D, rarement (personnellement : jamais).

[MatRem]

on laisse généralement ce choix, mais sous forme de conversions vers / depuis une représentation interne fixée

Il ne risque pas d'y avoir beaucoup de conversions, qui pourraient faire baisser un peu les performances?

chaque fonction de ta bibliothèque qui prendra en paramètre une couleur, devra être template.

Oui c'est vrai, même si une partie des classes qui se servent des couleurs n'utilise qu'une spécilisation (comme Material), est ce un problème?

En programmation 3D, rarement (personnellement : jamais).

Dans ce cas, je peux éviter le template...

[Laurent Gomila]

Il ne risque pas d'y avoir beaucoup de conversions, qui pourraient faire baisser un peu les performances?

Ca dépend de l'application. Mais en 3D il y a tellement d'autres choses à optimiser avant ça.

Oui c'est vrai, même si une partie des classes qui se servent des couleurs n'utilise qu'une spécilisation (comme Material), est ce un problème?

Non pas du tout, je voulais juste soulever un point que je pense important, après si ça ne pose aucun problème tant mieux

Dans ce cas, je peux éviter le template...

Et les autres types ?

[MatRem]

Et les autres types?
Tu veux parler des entiers? On s'en sert beaucoup de ça pour les couleurs?

[Laurent Gomila]

Disons qu'il y a deux types qui sont pratiques pour les composantes de couleurs : float et unsigned char. Après tu peux aussi manipuler des entiers 32 bits, mais là tu dépends de l'endianess.

Faut voir quel est le but de ta bibliothèque en fait.

[MatRem]

Pour l'instant elle me sert à factoriser les fonctionnalités d'OpenGL, pour mes tp de Synthèse d'images.
Quand est il plus intéressant de se servir des unsigned char que des float?

[Laurent Gomila]

Pour l'instant elle me sert à factoriser les fonctionnalités d'OpenGL, pour mes tp de Synthèse d'images.

Ok, donc je pense que tu peux rester sur du float uniquement.

Quand est il plus intéressant de se servir des unsigned char que des float?

Quand on manipule des pixels, généralement.

[adel_dz]

Juste un mot:
Si tu specialise un membre d'un template, tu n'as plus le droit de specialiser la classe entiere

[MatRem]

adel_dz> C'est ce que disais hylvenir .

Quand on manipule des pixels, généralement.

Quand on manipule des pixels à quel niveau (position, ...) ?

[Laurent Gomila]

Quand on manipule des pixels à quel niveau (position, ...) ?

Au niveau de leur couleur évidemment.

[MatRem]

Pour ce qui est d'OpenGL, ça correspond à la manipulation des fragments?

[Laurent Gomila]

Je parlais plus généralement. Par exemple lorsque tu charges une image à partir d'un fichier, tu auras très certainement les pixels sous forme de composantes entières non signées. Pareil lorsque tu vas manipuler une texture, à part les "nouveaux" formats en virgule flottante, ce sera des formats à base de composantes entières non signées.

[MatRem]

Ok d'accord, j'y étais pas .
Oui effectivement là c'est clair que les valeurs entières sont très utilisée.

Bon ben merci pour tes explications, et merci à tous les posteurs .