[Plan du site] Vous êtes ici --- > Le Site du Zéro > Les forums > Programmation > Langage C++ > [C++] La surcharge d'operateur > Lecture du sujet

[C++] La surcharge d'operateur

Commutativité?

Vous devez être inscrit pour pouvoir poster des messages

Résolu Le problème de ce sujet a été résolu

Page : 1

Auteur

Message

1 visiteur sur ce sujet (1 anonyme)

Page : 1

Aniem

# Posté le 12/05/2008 à 15:25:16

Groupe : Membres

Bonjour,

Voila : J'essaie de me creer une classe qui gère les nombres complexes ne l'ayant pas trouvé dans mes recherches (superficielles je l'admet) sur le C++, et surtout, pour m'entrainer un peu, et qui sait, ça peut etre utile

Le probleme vient lors de la definition des operateurs arithmetiques classiques : quand c'est deux complexes entre eux
pas de probleme, quand faut multiplier par un autre type de nombre, ça devient plus chiant, (les redefinir pour chacun, et les templates quand j'ai jeté un coup d'oeil il râle) mais je m'en sort.

Donc je peut Multiplier(ou additionner diviser, soustraire etc) un complexe par un complexe, un complexe par un nombre reel, un reel par un complexe...

Un reel par un complexe??? ah bah non il veut pas

Je pense que c'est parce qu'il cherche dans la def du type double (par exemple) et qu'il ne la trouve pas ...

Comment je peut lui dire d'aller voir ce que l'operation 5.2*Z veut dire dans la definition de la classe Complexe?? (Z etant deja defini comme un complexe), enfin si je peut ...

Merci

Édité le 12/05/2008 à 15:44:24 par Aniem

Hauru

# Posté le 12/05/2008 à 15:32:16

Groupe : Membres

Il faut surcharge &ostream::operator*(double nombre, Z complexe);

Édité le 12/05/2008 à 15:33:37 par Hauru

La bonne santé est la plus lente façon de mourir.

Chlab_lak

# Posté le 12/05/2008 à 15:42:43

Groupe : Membres

Cette réponse a aidé l'auteur du sujet

Citation : Aniem

J'essaie de me creer une classe qui gère les nombres complexes ne l'ayant pas trouvé dans mes recherches (superficielles je l'admet) sur le C++, et surtout, pour m'entrainer un peu, et qui c'est, ça peut etre utile

il y a std::complex<> dans <complex>

pour ton probleme, es ce que tu implemente les operateurs binaires en fonction libre ? si oui, tu pourras beneficier de la symetrie grace au conversion implicite (apres je sais pas si les complex le permette, je n'ai pas encore atteint cela en math)

nb: il y a eu une discussion similaire il y a environ un mois, cherche

Citation : Hauru

Il faut surcharge &ostream::operator*(double nombre, Z complexe);

n'importe quoi

- Developpez.com : FAQ C++
- Netecolo.com : Une page d'accueil pour la planète terre !
- Boost.org : La bibliothèque des programmeurs C++
- Charte du forum C++

youyou

# Posté le 12/05/2008 à 15:45:17

alea jecta es
Groupe : Membres

donne le code de la classe
sinon j'imagine qu'il faut implementer
Code : C++

complex operator*(double nombre, complex complexe)
{
return (complexe*nombre);
}

Édité le 12/05/2008 à 15:48:24 par youyou

Spaz

# Posté le 12/05/2008 à 15:50:13

Groupe : Membres

peut etre :
inline const Z operator*(const double d, const Z & z) {return z*d;}
?

edit:grilled

Édité le 12/05/2008 à 15:51:13 par Spaz

Hiura

# Posté le 12/05/2008 à 15:55:08

Groupe : Membres

Citation : Spaz

peut etre :
inline const Z operator*(const double d, const Z & z) {return z*d;}
?

Code : C++

1 2	Z z1(...), z2(...), z3(...); Z zn = (z1 * z2) + z3; // Erreur! l'objet temporaire z1*z2 est const -> pas de + possible.

FAQ

Tuto

Compiler facilement avec Qt

Doc

Spaz

# Posté le 12/05/2008 à 16:02:47

Groupe : Membres

Citation : hiura

Citation : Spaz

peut etre :
inline const Z operator*(const double d, const Z & z) {return z*d;}
?

Code : C++

1 2	Z z1(...), z2(...), z3(...); Z zn = (z1 * z2) + z3; // Erreur! l'objet temporaire z1*z2 est const -> pas de + possible.

parce que tous tes opérateurs sont mal déclarés ?
Sérieux, si ton opé + a pas ses 2 opérandes constantes ....
mais effectivement, j'ai le const en retour en trop

Édité le 12/05/2008 à 16:08:08 par Spaz

Chlab_lak

# Posté le 12/05/2008 à 16:03:14

Groupe : Membres

Code : C++

class Complex
{
   public:

      //...

      Complex &operator*=(const Complex &Other)
      {
          //...
      }
};

Complex operator*(const Complex &Me, const Complex &Other)
{
   return Complex(Me) *= Other;
}

- Developpez.com : FAQ C++
- Netecolo.com : Une page d'accueil pour la planète terre !
- Boost.org : La bibliothèque des programmeurs C++
- Charte du forum C++

Aniem

# Posté le 12/05/2008 à 16:18:25

Groupe : Membres

Citation : Chlab_lak

Citation : Aniem

il y a std::complex<> dans <complex>

Ok, j'ai toujours une porte de sortie, c'est déjà ça, merci de l'info

Citation : Chlab_lak

pour ton probleme, es ce que tu implemente les operateurs binaires en fonction libre ? si oui, tu pourras beneficier de la symetrie grace au conversion implicite (apres je sais pas si les complex le permette, je n'ai pas encore atteint cela en math)

nb: il y a eu une discussion similaire il y a environ un mois, cherche

Euh ... non je ne les ait pas mis en fonction libre ...

Je viens de voir la discussion d'il y a un mois ...
J'avais pas fais de recherche sur la surcharge avant de poster, c'est pas sérieux ...
Bon je vais les ait mises en fonction libre, et pour la conversion implicite (c'est mathématiquement faisable), il faut que je surcharge l'operateur adequat j'imagine ...

Cettte fonction à surcharger, j'imagine qu'elle ne doit pas etre en fonction libre, et est-ce que c'est operator() ??

Je l'ai fais pour les doubles, et il n'accepte que dans le sens complexe * double, qui n'est explicitement indiqué que pour complexe * complexe ( operator() a l'air d'etre le bon )

Mon code :

Header :

Code : C++

class Complexe {
    public :
        //Constructeurs
        Complexe(const double &reel=0, const double &imaginaire = 0); //Basique
        Complexe(const Complexe &complexecopie); //Constructeur de copie
        //Operations arithmetiques
        Complexe operator+(const Complexe &z);
        Complexe operator-(const Complexe &z);
        Complexe operator*(const Complexe &z);
        Complexe operator/(const Complexe &z);
              
        //Definition des comparaisons
        bool operator==(const Complexe &z);//égalité
        bool operator!=(const Complexe &z);//Différence
        bool operator<(const Complexe &z);//Inferiorité stricte lexicographique
        bool operator>(const Complexe &z);//Superiorité stricte lexicographique
        bool operator<=(const Complexe &z);//Inferiorité large lexicographique
        bool operator>=(const Complexe &z);//Superioté large lexicographique
        //Operateurs de Flux
        std::ostream operator<<(std::ostream &out);
        void afficher(std::ostream &out);
        //Copie
        Complexe operator=(const Complexe &z);
        //Accesseurs
        double Re();
        double Im();
        double Module();
        double Arg();
        //Modifieurs
        void setReal(const double &Re);
        void setIm(const double &Im);
 
        Complexe operator()(const double &i);
        //Autres operations elementaires :
        Complexe conjugue();
        
    
    private :
        double Real;
        double Imagi;
        double Rayon;
};

Complexe I(0,1);

Implementation des operateurs arithmétiques et operator() :

Code : C++

Complexe operator+(const Complexe &a, const Complexe &b){
    Complexe result(a.Re() + b.Re(), a.Im()+ b.Im());
    return result;
}

Complexe operator-(const Complexe &a, const Complexe &b){
    Complexe result( a.Re() - b.Re(), a.Im()-b.Im() );
    return result;
}

Complexe operator*(const Complexe &a, const Complexe &b){
    Complexe result(a.Re()*b.Re() - a.Im()*b.Im(), a.Im() * b.Re() + a.Re()*b.Im() );
    return result;
}

Complexe operator/(const Complexe &a, const Complexe &b){
    Complexe result( (a.Re() * b.Re() + a.Im() * b.Im()) / b.Module() , (a.Im() * b.Re() - a.Re() * b.Im()) / b.Module() );
    return result; 
}


Complexe Complexe::operator()(const double &i){
    Complexe result (i);
    return result;
}