Operator

complexe

complex

• dans ton opérateur

  +=

  , si tu additionnes z = a + i.b et z' = a'+i.b', tu calcules en réalité z devient ce qu'il était plus z + z' (donc z devient égal à 2z+z').
• dans ton opérateur

  *

  tu alloues un complexe mais tu retournes une référence alors que c'est inutile.

#include <ostream>
#include <iostream>

struct complex_t {
    double a;
    double b;

    complex_t(double a = 0, double b = 0):
        a(a),
        b(b)
    {}
};

inline std::ostream & operator << (std::ostream & out, const complex_t & z) {
    out << z.a << " + i." << z.b;
    return out;
}

inline complex_t operator + (const complex_t & z1, const complex_t & z2) {
    return complex_t(z1.a + z2.a, z1.b + z2.b);
}

inline complex_t operator + (const complex_t & z1, double d) {
    return complex_t(z1.a + d, z1.b);
}   

inline complex_t & operator += (complex_t & z1, const complex_t & z2) { 
    z1.a += z2.a;
    z1.b += z2.b;
    return z1;
}

inline complex_t & operator += (complex_t & z1, double d) {
    z1.a += d;
    return z1;
}

int main() {
    using namespace std;
    complex_t z1(3, 5); // 3 + i.5
    complex_t z2(10, 20);
    double d = 7;
    cout << "z1 = " << z1 << endl
         << "z2 = " << z2 << endl
         << "d  = " << d  << endl
         << "z1 + d = " << z1 + d << endl
         << "z2 + d = " << z2 + d << endl;
    z1 += z2;
    cout << "z1 += z2 --> z1 = " << z1 << ", z2 = " << z2 << endl;
    z1 += d;
    cout << "z1 += d  --> z1 = " << z1 << ", d = " << d << endl;
    return 0;
}

(mando@aldur) (~) $ g++ complex.cpp 
(mando@aldur) (~) $ ./a.out 
z1 = 3 + i.5
z2 = 10 + i.20
d  = 7
z1 + d = 10 + i.5
z2 + d = 17 + i.20
z1 += z2 --> z1 = 13 + i.25, z2 = 10 + i.20
z1 += d  --> z1 = 20 + i.25, d = 7

• inline

  peut être omis, c'est une optimisation
• les paramètres des opérateurs sont toutes des références (

  &

  ). Si le paramètre n'est pas modifié, on est supposé passer une const référence (voir

  +

  ). Sinon il faut passer juste une référence, comme dans

  +=

  )
• le premier paramètre correspond à l'opérande gauche, le second à l'opérande droite.
• le type de la valeur de retour dépend de la réponse à la question : ai-je dû ou non créer un

  complex_t

  dans l'opérateur. Si non : on retourne simplement une référence. Si oui, on retourne le type

  complexe_t

  .
• j'ai aussi défini l'opérateur

  <<

  afin de pouvoir afficher facilement un

  complex_t

  . La valeur de retour et l'opérande gauche sont toujours de type

  std::ostream &

  .
• note que le code proposé n'a pas de

  std::ostream &

  (on alloue ici dans le tas plutôt que dans la pile). En C++, qui dit

  new

  dit

  delete

  sinon cela engendre une fuite mémoire. Imagine le désastre sur une opération appelée hyper fréquemment, et on peut difficilement exiger de faire un delete à chaque addition !