surcharge d'oppérateur

Sujet résolu

11 octobre 2007 à 15:05:15

bonjour a tous

un petit soucis qui me taquine depuis quelques jours maintenant sur la surcharge d'oppérateur, et plus particulièrement avec cout.

en effet on a vu comment afficher un objet de type date avec cout dans le cours de matéo; par contre l'affichage de la somme de deux dates genere une erreur de compilation -_-'

j'ai bien tenté de créer d'autre surcharge; mais sans succès ...

mon programme est fait pour traiter des complexes (addition multiplication soustraction division) et je voudrait donc pouvoir faire

cout << complexe1 + complexe2;

mais voila sa ne marche pas ...

je post mon code ici :

complexe.h (definition de la classe)

#include <iostream>
#include "nombre.h"
#include <math.h>
class complexe : public nombre
{
private :
double m_a;
double m_b;
public :
void afficher(std::ostream &out);
double module();
double arg();
complexe conj();
double Re();
double Im();
complexe();
complexe(double a, double b);
complexe operator+(const complexe &c2);
complexe operator-(const complexe &c2);
complexe operator*(const complexe &c2);
complexe operator/(const complexe &c2);
};
std::ostream &operator<<(std::ostream &out, complexe &c1 );

complexe.cpp

#include "complexes.h"
using namespace std;
ostream &operator<<(ostream &out, complexe &c1 )
{
c1.afficher(out);
return out;
}
void complexe::afficher(ostream &out)
{
if (m_a!=0)
{
out << m_a;
if (m_b>0)
out << "+";
}
if (m_b!=0)
out << m_b << "i";
if (m_a == 0 && m_b == 0)
out << 0;
}
complexe complexe::operator+(const complexe &c2)
{
complexe resultat(m_a+c2.m_a, m_b+c2.m_b);
return resultat;
}
complexe complexe::operator-(const complexe &c2)
{
complexe resultat(m_a-c2.m_a, m_b-c2.m_b);
return resultat;
}
complexe complexe::operator*(const complexe &c2)
{
complexe resultat(m_a*c2.m_a - m_b*c2.m_b, m_a*c2.m_b + m_b*c2.m_a);
return resultat;
}
complexe complexe::operator/(const complexe &c2)
{
complexe temp(c2.m_a, -c2.m_b);
double module = sqrt(c2.m_a*c2.m_a + c2.m_b*c2.m_b);
if (module==0)
return c2;
complexe resultat((m_a*temp.m_a - m_b*temp.m_b)/module, (m_a*temp.m_b + m_b*temp.m_a)/module);
return resultat;
}
complexe complexe::conj()
{
complexe resultat(m_a,-m_b);
return resultat;
}
double complexe::Re()
{
return m_a;
}
double complexe::Im()
{
return m_b;
}
complexe::complexe()
{
m_a = 0;
m_b = 0;
}
complexe::complexe(double a, double b)
{
m_a = a;
m_b = b;
}

et le main :

#include <iostream>
#include "complexes.h"
using namespace std;
int main()
{
complexe c1(2.0,3.0);
complexe c2(0,3.0);
complexe c = c1 / c2;
cout << "(" << c1 << ") / (" << c2 << ") = " << c << endl;
complexe c3 = c1.conj();
cout << c3 <<endl;
cout << c3*c1 << endl; //erreur : no match for 'operator<<' in 'std::cout<< ($c3)->complexe::operator*((etc...)
cout << c3+c1 << endl; //erreur : idem avec +
return 0;
}

juste : nombre est une classe virtuelle pure pour pouvoir traiter les nombres indifféremment de leur type, elle est actuellement vide ...

si quelque peux m'aider sa serai simpas j'ai meme planté mon prof d'info sur le coup -_-'
merci en tout cas =)

minirop

11 octobre 2007 à 16:58:50

Essaie en mettant tes opérations entre parenthèses car là avec ce ci il va peut être essayer de multiplier "cout << c3" et "c1"

Nanoc

11 octobre 2007 à 20:55:02

Comme dirait lmghs, tes signatures ne sont pas correctes et l'erreur vient de là (de + et * et pas de cout)

Ne jamais oublier les passages par référence constante !!

P.S.: Il existe déjà une classe <complex> dans la STL, bien qu'elle ne soit pas super bien codée à mon avis, elle sera mieux si tu penses utiliser des complexes ailleurs. Sinon, ben c'est un excellent exercice.

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

lmghs

11 octobre 2007 à 21:36:32

Pas "const-correctes" je dirais plutôt -- et pas canoniques non plus, mais c'est une autre histoire (symétrie, tout ça).
Pour l'instant, cela ne va pas se voir avant un c1+c2+c3+c4+...+cn.

Mais c'est le fait que l'opérateur d'injection ne prenne pas une référence constante que tu observes ce que tu observes.
Chose qui t'obligera ensuite à déclarer const, comme il se doit, tes accesseurs -- la fonction afficher() ne servant à rien d'utile -- et on en revient en effet à un problème de const-correction.

J'en avais parlé dans ma critique du tuto, mais suite à un changement de forum, les liens sont cassés.

NB: m@téo, si tu me lis, ceci est la raison pour laquelle la const-correction est vachement importante en C++. C'est le coup à ne pas pouvoir afficher les résultats d'expressions sans passer par des temporaires nommés.

mrbuisson

12 octobre 2007 à 9:46:35

j'avoue ne pas avoir compris ta reponse, si tu pouvais etre un peu plus explicite ...
opérateur d'injection, post correction, c'est des termes assé technique (entre autre) que je doit traduire en code, ce qui n'est pas évident quand on ne vois pas a quoi cela correspond =)

lmghs

12 octobre 2007 à 9:55:06

"const", pas "post". En gros il manque tous les const qui pourraient être mis. Cf le dernier tuto de m@téo pour avoir un début de réponse -- je manque de temps pour l'instant.

Et l'opérateur d'injection, est celui qui permet d'injecter des objects dans les flux -> operator<<() qui doit devenir:
std::ostream& operator<<(std::ostream &os, TonType const& valeur)

mrbuisson

13 octobre 2007 à 1:47:50

j'ai fini par trouver la solution a ce problème (il s'agit effectivement de problèmes de const et cie)
et c'est vrai qu'il est plus logique après coup de déclarer les opérateurs numériques comme const

je garde la méthode afficher je trouve que le code est plus clair, je la met juste en const

enfin je vais tenter de respecter un peu plus la sémantique des const sa m'évitera d'autres erreurs par la suite (et c'est toujours mieux d'avoir du code propre non ?

)

je reviendrait certainement a la charge sur le sujet des complexe (ou un autre corps sa depend de l'humeur) alors a bientot et merci