Hum ca va pas, il y a des confusions.
Une méthode s'applique à *this, qui est en fait un paramètre à part entière de la méthode. En particulier dans tes méthodes les complexes déclarés en variables locales devraient en fait être *this. Par ailleurs tu ne peux pas accéder aux champs reel et imag des complexes autres que *this car ces membres sont privés. Ou alors si this n'est pas exploité, c'est que ton opérateur ne devrait pas être dans la classe.
Les paramètres de ton constructeurs ne sont pas exploités pour initialiser ton objet.
Par convention on ne met jamais de majuscules aux noms de méthode. A la rigueur on en met uniquement pour les noms de classe et en pratique c'est plutôt réservé aux paramètres templates.
Je vire la méthode init qui devrait en fait intervenir au niveau du constructeur.
Afin de condenser le programme j'ai rassembler la déclaration de tes méthodes et leur implémentation mais ta manière de faire est tout à fait juste (et même mieux).
Voici une façon de faire si on repart de ce qui est déjà fait :
#include <iostream>
class complexe{
private :
float reel;
float imag;
public :
complexe(float reel0 = 0, float imag0 = 0):
reel(reel0),imag(imag0)
{}
inline const float & re() const{
return reel;
}
inline const float & im() const{
return imag;
}
inline complexe multiplier_r(const float & r){
reel *= r; // reel équivaut à this->reel
return *this;
}
inline complexe multiplier_c(const complexe & c){
reel = re() * c.re() - im() * c.im();
imag = re() * c.im() - im() * c.re();
return *this;
}
inline complexe additionner_r(const float & r){
reel += r;
return *this;
}
inline complexe addionner_c(const complexe & c){
reel = re() + c.re();
imag = im() + c.im();
return *this;
}
inline void affich() const {
std::cout << " " << re() << " + " << im() << "i" << std::endl;
};
};
inline complexe operator + (const complexe & c,const float & r){
complexe res(c);
res.additionner_r(r);
return res;
}
inline complexe operator + (const float & r,const complexe & c){
return c + r;
}
inline complexe operator + (const complexe & x,const complexe & y){
complexe res(x);
res.addionner_c(y);
return res;
}
// idem pour *
int main(){
complexe c(1,2), c1(2,2);
c.addionner_c(c1);
c.affich();
return 0;
}
Voici comment on peut faire uniquement avec des opérateurs :
#include <iostream>
#include <ostream>
// La classe des imaginaires purs ------------------------------
// Cette classe encapsule un imaginaire pur par exemple z = 69i
class imaginaire{
protected:
float imag;
public:
imaginaire(const float & x):imag(x){}
inline const float & im() const{
return imag;
}
inline void set_im(const float & x){
imag = x;
}
};
// Grace à cet opérateur je peux directement écrire un imaginaire dans un flux,
// par exemple std::cout, std::cerr, ou n'importe quel std::ofstream (fichier
// ouvert en écriture)
inline std::ostream & operator << (std::ostream & out,const imaginaire & x){
out << x.im() << 'i';
return out;
}
// L'addition des imaginaires purs
inline imaginaire operator + (const imaginaire & x,const imaginaire & y){
return imaginaire(x.im() + y.im());
}
// La multiplication des imaginaires purs
inline float operator * (const imaginaire & x,const imaginaire & y){
return - (x.im() * y.im());
}
// Le produit d'un imaginaire par un réel
inline float operator * (const imaginaire & x,const float & y){
return imaginaire(y * x.im());
}
// Pour le produit d'un réel et d'un imaginaire, je réutilise l'opérateur précédent
// Il s'agit bien d'un opérateur différent de :
// inline float operator * (const imaginaire & x,const float & y)
inline float operator * (const float & x,const imaginaire & y){
return y * x;
}
// La classe des complexes ------------------------------
// Comme je suis une grosse flemmarde je vais réutiliser par héritage la classe
// imaginaire que je viens de définir pour implémenter un complexe. Grosso modo
// un complexe c'est un imaginaire enrichi d'une partie réelle, donc l'héritage
// prend tout son sens. En particulier je pourrais directement utiliser les
// méthodes de la classe imaginaire sur un complexe (par exemple im())
class complexe : public imaginaire{
private:
float reel;
public:
complexe(float reel0 = 0,float imag0 = 0):
imaginaire(imag0),
reel(reel0)
{}
complexe(const imaginaire & x):
imaginaire(x),
reel(0)
{}
inline const float & re() const{
return reel;
}
inline void set_re(const float & x){
reel = x;
}
};
// Ecriture : ici je réutilise :
// inline std::ostream & operator << (std::ostream & out,const imaginaire & x)
inline std::ostream & operator << (std::ostream & out,const complexe & x){
out << x.re() << '+' << imaginaire(x.im());
return out;
}
// Addition
// J'aurais pu réutiliser l'addition des imaginaires mais bon ici c'est quand même
// plus lisible comme ça...
complexe operator +(const complexe & x,const complexe & y){
return complexe(
x.re() + y.re(),
x.im() + y.im()
);
}
// Cette fonction template va permettre d'additionner
// un objet de type T à un complexe. Il faut juste avoir un constructeur
// convertissant un objet de type T en complexe pour que cette fonction
// ait un sens (donc un imaginaire ou un float)
template <typename T>
complexe operator + (const complexe & x,const T & y){
return x + complexe(y);
}
// Même chose pour additionner un objet de type T à gauche
template <typename T>
complexe operator + (const T & x,const complexe & y){
return complexe(x) + y;
}
// Multiplication
inline complexe operator * (const complexe & x,const complexe & y){
return complexe(
(x.re() * y.re()) - (x.im() * y.im()),
(x.re() * y.im()) + (x.im() * y.re())
);
}
template <typename T>
complexe operator * (const complexe & x,const T & y){
return x * complexe(y);
}
template <typename T>
complexe operator * (const T & x,const complexe & y){
return complexe(x) * y;
}
// Le main ------------------------------
int main(){
complexe x(1,2), y(2,2);
std::cout << "x = " << x << std::endl
<< "y = " << y << std::endl
<< "x + y = " << x + y << std::endl;
imaginaire z(7);
std::cout << "z = " << z << std::endl
<< "x + z = " << x + z << std::endl;
return 0;
}
Et à l'exécution :
x = 1+2i
y = 2+2i
x + y = 3+4i
z = 7i
x + z = 1+9i
En espérant que ça t'ai aidé, bon courage !
complexe.h :
#include<iostream> class complexe { private : float reel; float imag; public : void init_complexe(float, float); complexe MultiplierR(float); complexe MultiplierC(complexe); complexe AdditionnerR(float); complexe AddionnerC(complexe); complexe DiviserC(complexe); void affich(); };main.cpp :
#include"complexe.h" #include"string.h" using namespace std; void main() { complexe c, c1; c.init_complexe(1,2); c1.init_complexe(2,2); c.AddionnerC(c1); c.affich(); } // z1=5+3i // z2=2-i // z1*z2=(5*2)-5i+(3i*2)-(3i*i) // z1+z2=(5+2)+(3-1)iMERCI :)
P.S. Normalement le programme principal devrait réaliser l'addition de deux matrices nxn de nombres complexes, mais comme je ne savais pas comment le faire, je me suis contentée d'effectuer quelques méthodes simples.