Discussion :

[babar63]

Bonjour a tous,
Etant encore a la decouverte du monde merveilleux des templates j'ai rencontré une erreur en essayant de spécialisé une fonction membre de ma classe template. Voila le 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<typename T>
class Vector2D
{
public:
....
//ma fonction à spécialiser :
template<typename T2> static T2 norm(const Vector2D<T> & myVector2D); //fonction statique template permettant de calculer la norme et de retourner le type T2.
};
 
//declaration de la fonction :
template<typename T>
template<typename T2>
T2 Vector2D<T>::norm(const Vector2D<T> & myVector2D)
{
	...//aucun probleme avec la declaration de cette fonction
}
 
//specialisation souhaité :s
template<typename T>
template<>
int Vector2D<T>::norm(const Vector2D<T> & myVector2D)
{
	...//erreur de compilation la fonction ne correspond a aucun modele???
}

Voila le probleme je n'ai pas trouvé de solution pour spécialiser cette fonction (excepté remplacer le retour du type T2 par un argument supplémentaire!!) est-ce un probleme de syntaxe ou simplement c'est impossible?
merci d'avance
Bonne journée

[Alp]

La signature d'une fonction ne dépend que du nom et des arguments(leurs types) de cette fonction.
Le type de retour n'est pas pris en compte.
Autrement dit, tu dois par exemple rajouter un argument bidon qui serait du type de la valeur de retour.
(pourquoi ne pas retourner un réel dans tous les cas ? Un entier est un réel, donc pas de soucis)

[babar63]

pourquoi ne pas retourner un réel dans tous les cas ? Un entier est un réel, donc pas de soucis

Oui je suis d'accord avec toi mais si je retourne un float je risque une troncation dans le cas ou je travaillerai avec des doubles(par exemple), et si je retourne un double je perds de la "place" pour rien lorsque je travaille avec float, int...
Ces détails sont peut etre dérisoires mais j'aime faire les choses bien
Il n'existe donc pas d'autre solution que de rajouter un parametre supplémentaire?

[koala01]

Salut,

Dans le sens où tu t'attends sans doute à ce que le retour de ta fonction soit de type T (et non de type T2), pourquoi ne pas faire un truc du genre de

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 T>
class Vector2D
{
    public:
        typedef typename T __type;
        typedef std::vector<__type> vector;
        Type Norme(const vector& tab)
        {
             /*comportement par défaut*/
        }
}
 
template <>
double Vector2D<double>::Norme(const std::vector<double>& tab)
{
   /* compoirtement spécialisé pour les doubles */
}
 
template <>
float Vector2D<float>::Norme(const std::vector<float>& tab)
{
   /* compoirtement spécialisé pour les floats */
}
/* autres spécialisations */

(je *crois* que cela devrait fonctionner comme cela )

[babar63]

Oui ca dervrait fonctionner le probleme c'est que je ne m'attend pas a ce que le retour de ma fonction soit de type T!
Par exemple si je travaille sur des vecteur entiers et je souhaite connaitre la norme, (excepté quelques cas bien rare) il me faut retourner un float.

[koala01]

Mais, dans ce cas, pourquoi ne pas effectivement d'office travailler avec des réels pour le retour quelque chose qui deviendrait

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 T>
class Vector2D
{
    public:
        typedef typename T __type;
        typedef std::vector<__type> vector;
        double /* ou float */ Norme(const vector& tab)
        {
             double ret= /* calcule de la norme avec un transtypage de tous les __type en float */
             return ret;
        }
}
 
template <>
double Vector2D<double>::Norme(const std::vector<double>& tab)
{
   /* compoirtement spécialisé pour les doubles */
}
 
template <>
double Vector2D<float>::Norme(const std::vector<float>& tab)
{
   /* comportement spécialisé pour les floats */
}
/* autres spécialisations */

[babar63]

Comme je l'ai marqué plus haut :

Oui je suis d'accord avec toi mais si je retourne un float je risque une troncation dans le cas ou je travaillerai avec des doubles(par exemple), et si je retourne un double je perds de la "place" pour rien lorsque je travaille avec float, int...
Ces détails sont peut etre dérisoires mais j'aime faire les choses bien

C'est sans doute la meilleure solution mais j'aimerais une fonction plus 'générique' (si possible bien entendu )