Discussion :

[SKone]

Bonjour
J'ai un problème lors du développement d'une classe j'ai eu à surchargé l'opérateur '==' mais je voudrais surchargé de manière différence si je suis face à un float, double ou long double :
voici ma classe

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
template <class T>
class A
{
T x;
bool operator==(const A<T>&) const;
};
 
template <class T>
bool A<T>::operator==(const A<T>& a) const
{
	return a.x == x;
}
 
template <>
bool A<float>::operator==(const A<float>& a) const
{
	return std::abs(a.x - x) <= std::numeric_limits<float>::epsilon();
}
 
typedef A<int> iA;
typedef A<unsigned int> uiA;
typedef A<short> sA;
typedef A<long> lA;
typedef A<float> fA;
typedef A<double> dA;
typedef A<long double> ldA;

Comme vous le voyez à cause des typedef j'ai une multiple définition. Est-ce que vous voyez une solution tout en bénificiant des avantages de la "généricité". Merci

[lemmel]

peut être avec ca :

http://cpp.developpez.com/cours/cpp/

[NiamorH]

Je n'ai pas d'erreur de compilation sous Comeau Online.

Mis à part

Code :

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

template <class T>

[SKone]

[Edit du premier message] j'ai corrigé le class T mais ça ne viens pas de là. La spécification pour float existe pour A<int>, A<unsigned int>, ... Ainsi que pour A<float>, ... Donc normalement ça ne ce compile pas... En tout cas avec g++. Ça compile sans problème sauf au moment du link j'ai :
obj\Debug\e_Motion_VisionMain.o:: In function `ZNK3eMV8Vector3DIfEeqERKS1_':C:/Documents and Settings/solène/Mes documents/dossier a soufiane/e-Motion-Vision//Vector3D.hpp:126: multiple definition of `eMV::Vector3D<float>::operator==(eMV::Vector3D<float> const&) const'
ne\Mes documents\dossier a soufiane\e-Motion-Vision\Vector3D.hpp:126: first defined here
...
Voilà mon code :
Vector3D.h
Vector3.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#define Type(X) typedef X<char>             c  ## X;\
                typedef X<unsigned char>    uc ## X;\
                typedef X<short>            s  ## X;\
                typedef X<unsigned short>   us ## X;\
                typedef X<int>              i  ## X;\
                typedef X<unsigned int>     ui ## X;\
                typedef X<long>             l  ## X;\
                typedef X<unsigned long>    ul ## X;\
                typedef X<size_t>           z  ## X;\
                typedef X<float>            f  ## X;\
                typedef X<double>           d  ## X;\
                typedef X<long double>      ld ## X

[NiamorH]

C'est parce que ta fonction n'est pas inline alors qu'elle se trouve dans un .h

Soit tu la met inline, soit tu la déclare seulement dans le .h et tu l'implémente dans le cpp.

Les typedefs n'instancient pas les classes, ils ne peuvent pas être en cause.

[SKone]

Je ne peux pas la mettre dans un *.cpp puisque c'est une classe générique alors qu'inclue un fichier *.hpp. Et même en déclarant inline ou sans comme je l'es montré dans la vrai classe ça Bug Quand même.

PS : Ne pas tenir compte de la première classe mais des liens Vector3D.h Vector3.hpp

[NiamorH]

Salut, plutôt que de placer inline devant les déclarations, essaye de le placer devant les définitions des fonctions.

Je ne suis pas sûr qu'une fonction déclarée friend inline le soit vraiment, vu qu'elle n'apartient pas à la classe.

[Jean-Marc.Bourguet]

Je ne peux pas la mettre dans un *.cpp puisque c'est une classe générique alors qu'inclue un fichier *.hpp.

Les specialisations explicites completes ne sont pas des templates mais des vraies definitions. Si tu veux eviter la duplication, il faut les declarer dans les entetes et les definir une seule fois.

Et même en déclarant inline ou sans comme je l'es montré dans la vrai classe ça Bug Quand même.

Les specialisations ne sont pas inline.


En passant, ton idee de specialiser la comparaison pour les instantiations sur les flottants est deja contestable. Ton implementation elle est erronee sans debat possible. J'ai deja explique comment faire et j'ai la flemme de chercher le message precis.

[SKone]

En effet ça marche tu pourrais m'expliqué pourquoi en mettant le Inline dans la définition ça marche

[Jean-Marc.Bourguet]

En effet ça marche tu pourrais m'expliqué pourquoi en mettant le Inline dans la définition ça marche

Comme pour n'importe quelle definition de fonction non template.

[NiamorH]

Je t'ai dit, les opérateurs déclarés friend ne sont pas membres de la classe. Il n'y a donc pas de raison que la classe puisse avoir une influence sur l'inline ou pas de l'opérateur.

Imagine une fonction void func(); du namespace global et deux classes A et B.

A déclare friend void func() et B déclare friend inline void func().

Comment le compilateur décide si il faut inliner ou pas ?

Par habitude je place le mot clef inline devant mes définitions, toujours.

[SKone]

Résolu.

Mais en quoi faire :

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
template <class T>
inline bool Vector3D<T>::operator==(const Vector3D<T> &v) const
{
    return (x == v.x && y == v.y && z == v.z);
}
 
template <>
inline bool Vector3D<float>::operator==(const Vector3D<float> &v) const
{
    const float epsilon = std::numeric_limits<float>::epsilon();
    return (fFunc::abs(x - v.x) <= epsilon &&
            fFunc::abs(y - v.y) <= epsilon &&
            fFunc::abs(z - v.z) <= epsilon);
}
 
template <>
inline bool Vector3D<double>::operator==(const Vector3D<double> &v) const
{
    const double epsilon = std::numeric_limits<double>::epsilon();
    return (dFunc::abs(x - v.x) <= epsilon &&
            dFunc::abs(y - v.y) <= epsilon &&
            dFunc::abs(z - v.z) <= epsilon);
}
 
template <>
inline bool Vector3D<long double>::operator==(const Vector3D<long double> &v) const
{
    const long double epsilon = std::numeric_limits<long double>::epsilon();
    return (ldFunc::abs(x - v.x) <= epsilon &&
            ldFunc::abs(y - v.y) <= epsilon &&
            ldFunc::abs(z - v.z) <= epsilon);
}

Est faux ? Et comme les flottants engendre des erreurs en quoi c'est contestable de les spécialisées ? La seul raison est que:
std::numeric_limits<int>::epsilon() = 0;

[Jean-Marc.Bourguet]

Quelle est la definition d'epsilon? En quoi est-ce que c'est un borne pertinente?

[Sylvain Togni]

À noter aussi qu'un opérateur == utilisant un epsilon ne sera pas transitif.

[SKone]

Si je prends 2*epsilon ça pourrait marché ? Enfin c'est du bricolage mais ça peut marché... Et la transitivité sera respecté ?

[NiamorH]

Ben... non, l'écart sera juste plus grand. Il restera des cas où a==b et b==c mais a!=c

[SKone]

Donc quel méthode propose tu pour faire face à ce genre de problème. => Au problème engendré par les erreurs dû au flottant... ?

[NiamorH]

Tout dépend du domaine d'utilisation.

Si tu travaille sur un projet de jeu video qui ne demande pas une grande précision dans les calculs, tu pourras te permettre des erreurs sur les flottants sans que ce soit visible à l'oeil du joueur.

Si tu fais une appli pour la Nasa, je doute que tu utilises la même représentation des nombres flottants.

Tu ne peux pas trouver une seule solution générique pour ce probleme qui satisfasse tout les utilisateurs de ta bibli.

[SKone]

Je fais un moteur Physique qui n'as pas pour but le temps réel donc je demande une grande précision mais pour l'instant je n'est pas encore codé ma classe pour les nombres flottants très précis. Si la fonction epsilon est là dans le standard c'est bien que le nombre retourné est l'epsilon que je cherche ?

[HanLee]

Je fais un moteur Physique qui n'as pas pour but le temps réel donc je demande une grande précision mais pour l'instant je n'est pas encore codé ma classe pour les nombres flottants très précis. Si la fonction epsilon est là dans le standard c'est bien que le nombre retourné est l'epsilon que je cherche ?

Cet epsilon est le plus petit flottant non nul tel que 1.0 + epsilon != 1.0 en fait.

Il faudrait ajuster cet epsilon avec les valeurs considérées, pour être plus juste.

Mais là encore, c'est plus ou moins valable selon les applications, et sûrement suffisant pour les jeux vidéos.