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

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

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

donne le code de la classe
sinon j'imagine qu'il faut implementer

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

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

edit:grilled

Citation : Spaz

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

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

Citation : hiura

Citation : Spaz

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

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

class Complex
{
   public:

      //...

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

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

Citation : Chlab_lak

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 sait, ça peut etre utile

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 :

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() :

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;
}

EDIT : Bon c'est bon, je n'avais pas mis

friend Complexe operator+(const Complexe &, const Complexe &);

dans le Header

REDIT : operator() n'est pas l'operateur a utiliser pour "convertir" (faire le transtypage)

http://www.dinkumware.com/manuals/?man [...] =complex.html