Exercice de redéfinition des opérateurs internes et externes c++

//Exercice de redéfinition des opérateurs internes et externes
//Exercice 52 ,nombres complexes surcharge d'operateurs
#include <iostream>
using namespace std;
/***********************************************************************/
/***********************************************************************/
class Complexe {
    public:
    //Complexe ();
    Complexe (double _r,double _i);//Constructeur avec 2 doubles
    Complexe(Complexe *c);//Constructeur depuis un Complexe

    double getR()const ;//récupére la partie réelle du nombre  R
    double getI()const ;//récupére la partie imaginaire  du nombre i

    void setR(double _r) ;//Set partie réeelle R
    void setI(double _i) ;//Set partie imaginaire i

    //Surcharge interne operateur ==
    bool operator==(const Complexe& c) const ;

    //Surcharge interne operateur +
    Complexe operator+(const Complexe& c) ;

    //Surcharge interne operateur +=
    void operator+=(const Complexe& c)  ;

    //Surcharge interne operateur -=
    void operator-=(const Complexe& c) ;

    //Surcharge interne operateur *=
    void operator*=(const Complexe& c) ;

    private:
    double r,i ;//Partie reel et imaginaire
};

Complexe::Complexe(double _r=0.0,double _i=0.0):r(_r),i(_i){}
Complexe::Complexe(Complexe *c):r(c->getR()),i(c->getI()){}

double Complexe::getR() const{return r;}
double Complexe::getI() const{return i;}

void Complexe::setR(double _r){r=_r;}//Set partie réeelle R
void Complexe::setI(double _i){i=_i;}//Set partie imaginaire i

//Operateur Interne == l'opérateur interne == est redéfini
bool Complexe::operator==(const Complexe& c) const {
    if ( r==c.getR() && r==c.getI() ){return true;}
    return false;
}

//Operateur Interne + l'opérateur interne + est redéfini
Complexe Complexe::operator+(const Complexe& c) {
    Complexe tmp;

    tmp.setR(r+c.getR());
    tmp.setI(i+c.getI());
    return tmp;

}

//Operateur Interne += l'opérateur interne += est redéfini
void Complexe::operator+=(const Complexe& c) {
    r=r+c.getR();
    i=i+c.getI();
}

//Operateur Interne += l'opérateur interne -= est redéfini
void Complexe::operator-=(const Complexe& c) {
    r=r-c.getR();
    i=i-c.getI();
}

//Operateur Interne *= l'opérateur interne *= est redéfini
void Complexe::operator*=(const Complexe& c) {
    Complexe tmpA(this);
    Complexe tmpB(c);

    r= tmpA.getR() * tmpB.getR() + (tmpA.getI() * tmpB.getI())*(-1) ;//R

    i=  (tmpB.getR() * tmpB.getI()) + ( tmpB.getR() * tmpA.getI()) ;//i

}



/***********************************************************************/
/***********************************************************************/
//Operateurs externes
//Operateur externe cout<< , l'opérateur  << externe est redéfini
ostream& operator<<(ostream& sortie , const Complexe& c){
    cout <<c.getR()<<"+i"<<c.getI();
    return sortie;
}


/***********************************************************************/
/***********************************************************************/
int main (){
    Complexe defaut;
    Complexe zero (0.0,0.0);
    Complexe un (1.0,0.0);
    Complexe i(0.0,1.0);
    Complexe y(0.2,3.0);
    Complexe j;
    Complexe trois(y);
    Complexe deux (2.2,4.3);


    cout <<zero <<" ==? "<<defaut;
    //avec l'opérateur interne == redéfini on effectue une comparaison
    cout << ((zero == i) ?" oui ":" non "); //Comparaison ==

    j=un+y;//Complexe un +y  somme

    //Avec la surcharge de l'opérateur  cout << on voit la valeur du complexe R+i
    cout <<endl<<"J= "<<j<<endl;

    cout <<trois<<endl;//cout << surcharge

    trois+=un;//somme +=

    cout <<trois<<endl;

    deux-=y;//Soustraction  -=

    cout <<deux<<endl;


    Complexe quatre(4.0,3.0);

    quatre *= quatre;//Multiplication *=

    cout <<quatre<<endl;//cout << surcharg

    return 0;
}