C++

Probleme de surcharge d'opérateur et de fonction amies

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Probleme de surcharge d'opérateur et de fonction amies

titeuf789

Bonjour, j'aurais besoin d'explication pour mon programme. Voici la situation , j'aimerais en gros réaliser les operations suivantes :

Code :

/*******************************test.cc***********************/
Longueur L(100);
Temps T (10);
Vitesse V (40);
double d;
L= V * T; ==>ok
V = V * 2; ==>ne marche pas
V = V * V ==>ok
V = 2 * V; ==>ok
d = V * V; ==>ne marche pas

J'ai donc deux problémes que je n'arrive pas à résoudre, voici mon code :

Code :

/*******************************grandeur.h***********************/
template <typename TYPE>
class Grandeur{
Grandeur(double tval=0):val(tval){};
public:
Grandeur(double tval=0):val(tval){};
inline double getVal() const{
return val;
}
friend inline TYPE operator * (const TYPE& t1,const TYPE& t2){
return TYPE(t1.val * t2.val);
}
protected:
double val;
};
class Longueur : public Grandeur<Longueur>{
public:
Longueur(double tval=0):Grandeur<Longueur>(tval){}
};
class Temps : public Grandeur<Temps>{
public:
Temps(double tval=0):Grandeur<Temps>(tval){}
};
class Vitesse : public Grandeur<Vitesse>{
public:
Vitesse(double tval=0):Grandeur<Vitesse>(tval){}
Longueur operator * (const Temps& t) const;
};
inline Longueur Vitesse::operator * (const Temps& t) const{
return Longueur(val * t.getVal());
}

Déjà je ne comprend pas vraiment pourquoi V = 2 * V me rend un resultat correct puisque d'apres ce que j'ai compris une classe fille ne peut pas se servir des fonctions amies de la classe mére ??? mais il me fallait des fonctions non membre pour réaliser cette opération.

Pour V = V * 2 par contre, le compilateur me sort :

erreur: ambiguous overload for ‘operator*’
note: candidats sont: Longueur Vitesse::operator*(const Temps& ) const
note: Vitesse operator*(const Vitesse&, const Vitesse& )

Le nombre ne connait donc pas son type de convertion, c'est donc mon modéle qui est faux mais je ne voit pas comment organiser les choses différemment. Je pensais a surcharger l'operateur de convertion des doubles sinon, dans la classe générique :

Code :

TYPE operateur double(){
return TYPE(val);
}

mais le compilateur n'aime pas apparemment ...

Le dernier test d = V * V reste un mystére, j 'ai l'erreur suivante :
erreur: cannot convert ‘Vitesse’ to ‘double’ in assignment

Je ne comprend pas pourquoi le double n'est pas transformer en une instance de Vitesse, puisqu'il le fait très bien lors de la multiplication 2*V , j'ai donc essayé de réécrire l'opérateur d'affectation mais toujours rien ...

Donc voilà je ne sais plus trop quoi faire et une petite aide serait la bien venue, merci d'avance

Publicité

KangOl

Profil : pointeur

[icode]operator double()[/icode] doit renvoyer un double

ca reglera ton dernier test...

----
note: pour la balise, http://kangol.prout.be/gm/md_inlinecode.user.js

titeuf789

ca régle quoi en fait ? je comprend pas trop le principe

KangOl

Profil : pointeur

bha vu que tu lui dit comment convertir en double, il le sais ...

titeuf789

mais en fait ce que je voulais en faisant ça c'était de contourner l'ambiguitée qu'il y avait en transformant un double en un élément de la classe fille , ca ne m'intéresse pas de convertir en double . Je dois m'être mal organisé dans l'héritage ou je ne sais quoi, je bloque complétement ...

KangOl

Profil : pointeur

fais des typedef, ca ira plus vite

titeuf789

ou ca des typedef ?

Joel F

Real men use unique_ptr

tu me copieras 10000 fois :

"les operateurs binaires ne s'implantent pas comme des fonctions firends masi comme des fonctiosn libres"

Message cité 1 fois

Ace17

Joel F a écrit :

tu me copieras 10000 fois :

"les operateurs binaires ne s'implantent pas comme des fonctions firends masi comme des fonctiosn libres"

Et pourquoi pas des friends?

Message cité 1 fois

titeuf789

mais je suis obliger de faire appel a une fonction non membre , sinon je ne peut pas résoudre l'opération V = 2 * V par exemple , j'ai vu ca sur ce site :
http://www.emse.fr/~boissier/ensei [...] non-membre

ça avais l'air d'être des cours donc bon ...

Publicité

Joel F

Real men use unique_ptr

Ace17 a écrit :

Et pourquoi pas des friends?

parce que les operateurs binaires de type +-*/ sont symmétriques. Dans a+b, a n'a pas de rôle à jouer face à b, ca elimine d'office la fonction memebre. Reste donc fonction libre ou amie.
La Fonction ami pete l'encapsulation alors que la fonction libre suffit a faire ce dotn tu as besoin en utilisant les accesseurs/mutateurs qui vont bien.

Quant à V =2*V ... faudra voir à mettre des ocnstructeurs explicites, écrire une Forme Canonique de Coplien et a pas utiliser le Bartman&Norton's Trick quand on sait pas s'en servir à bon escient.

Ah ouais, et pour preparer vendredi, ce cours est à chier

une version g++ compliant :

Code :

#include <iostream>
using namespace std;
template <typename TYPE> class Grandeur
{
public:
Grandeur(double tval=0):val(tval){};
inline double getVal() const{ return val; }
protected:
double val;
};
class Longueur : public Grandeur<Longueur>
{
public:
Longueur(double tval=0):Grandeur<Longueur>(tval){}
Longueur(const Grandeur<Longueur>& src):Grandeur<Longueur>(src.getVal()){}
};
class Temps : public Grandeur<Temps>
{
public:
Temps(double tval=0):Grandeur<Temps>(tval){}
Temps(const Grandeur<Temps>& src):Grandeur<Temps>(src.getVal()){}
};
class Vitesse : public Grandeur<Vitesse>
{
public:
Vitesse(double tval=0):Grandeur<Vitesse>(tval){}
Vitesse(const Grandeur<Vitesse>& src):Grandeur<Vitesse>(src.getVal()){}
};
template<class T1,class T2> struct unit;
template<class T> struct unit<T,T> { typedef T type; };
template<> struct unit<Temps,Vitesse> { typedef Longueur type; };
template<> struct unit<Vitesse,Temps> { typedef Longueur type; };
template<class T1,class T2>
Grandeur< typename unit<T1,T2>::type >
operator*( const Grandeur<T1>& t1, const Grandeur<T2>& t2 )
{
typedef typename unit<T1,T2>::type unit_type;
typedef Grandeur<unit_type> return_type;
return return_type( t1.getVal()*t2.getVal() );
}
template<class T>
Grandeur<T> operator*( const double& t1, const Grandeur<T>& t2 )
{
typedef Grandeur<T> return_type;
return return_type( t1*t2.getVal() );
}
template<class T> Grandeur<T> operator*( const Grandeur<T>& t1, const double& t2 )
{
typedef Grandeur<T> return_type;
return return_type( t1.getVal()*t2 );
}
int main()
{
Longueur L(100);
Temps T (10);
Vitesse V (40);
Longueur L2 = V*T;
cout << L2.getVal() << endl;
V = V*2;
cout << V.getVal() << endl;
V = 0.5*V;
cout << V.getVal() << endl;
}

Ensuite tu m'expliqueras comme Vitesse*Vitesse ca donne un double OU une vitesse au carré, c'est pas homogène

Message cité 1 fois

Ace17

Joel F a écrit :

parce que les operateurs binaires de type +-*/ sont symmétriques. Dans a+b, a n'a pas de rôle à jouer face à b, ca elimine d'office la fonction memebre. Reste donc fonction libre ou amie.

Jusque-la, je suis completement d'accord avec toi.

Joel F a écrit :

La Fonction ami pete l'encapsulation alors que la fonction libre suffit a faire ce dotn tu as besoin en utilisant les accesseurs/mutateurs qui vont bien.

Je ne vois pas en quoi la fonction amie "pete" l'encapsulation ... peux-tu me donner un exemple ou l'emploi des fonctions amies est justifie, dans ce cas? N'existe-t-il pas des cas ou un operateur binaire doit manipuler des membres prives auquels il serait peu judicieux de donner acces, meme a travers un accesseur?

Message cité 1 fois

IrmatDen

Ace17 a écrit :

Je pense que c'est comme tu dis: 'des cas'. Donc à n'utiliser que lorsque l'usage y est strictement nécessaire... à mon avis.

Message cité 1 fois

titeuf789

Franchement c'est ingénieux comme truc j'aurais jamais pensé a une implémentation comme ça, pour Vitesse*Vitesse ça devrait rendre un double mais je pense que je m'en sortirais. Je te remercie parce que j'étais vraiment bloqué

Joel F

Real men use unique_ptr

IrmatDen a écrit :

Je pense que c'est comme tu dis: 'des cas'. Donc à n'utiliser que lorsque l'usage y est strictement nécessaire... à mon avis.

C'est exactement ça. Si tu peut pas faire autrement, vas y fait une fonction amie. Mais, à l'usage, tu t'apercevra que, dans 99.999999932648% des cas,
t'en a pas besoin car tu as ta pelleté d'accesseur/mutateur.

@titeuf789 : je comprends pas pkoi vitesse*vitesse ca devrait renvoyer un double o_O c'est physiquement incorrect.

@le reste :
Pour infos : http://boost.org/libs/mpl/doc/tuto [...] lysis.html
Boost::MPL fournit un exemple avec une implantation plus poussée mais utilisant le même genre d'idée.

FORUM HardWare.fr

Programmation

C++

Probleme de surcharge d'opérateur et de fonction amies

Sujets relatifs
fonction(quelle image est dans mon clip)	[easyphp] Probleme d'administration
problème flash cliquable sous IE6	probleme de compilation sous KEIL
[RESOLU] Probleme pour augmenter un DIV en fonction d'un autre	problème XMLBeans sous eclipse
probléme gotoAndPlay	C++ openGL problème couleur
fonction poll() en C sous linux
Plus de sujets relatifs à : Probleme de surcharge d'opérateur et de fonction amies

Page générée en 0.133 secondes