Bonjour à tous,

Voila, je suis sur un petit programme destiné à comprendre le fonctionnement des classes abstraites, surcharge d'operateur, friend.

Le but etant d'avoir 2 classes, polaire et cartésien et pouvoir faire les opération de base addition et multiplication. ces 2 classes hérites de la classe abstraite Complexe. Je vais vous montrer mon code actuel, mon probleme se trouve lors de la compilation à propos de la surcharge d'operateur.

Complexe.hpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef COMPLEXE_HPP
#define COMPLEXE_HPP
 
class Complexe{
 
protected:
  double X;
  double Y;
  double rho;
  double teta;
 
public:
  void affiche();
  virtual void enregistre(double,double)=0;
  virtual double partie_reelle()=0;
    virtual double partie_imaginaire()=0;
    virtual double module()=0;
  virtual double argument()=0;
  friend Complexe operator+(Complexe, Complexe);
  friend Complexe operator*(Complexe, Complexe);
};
 
#endif
Complexe.cpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include "Complexe.hpp"
#include "Cartesien.hpp"
#include "Polaire.hpp"
 
using namespace std;
 
Complexe operator+(Complexe c1, Complexe c2){
     Complexe c;
     c.enregistre(c1.partie_reelle()+c2.partie_reelle(), c1.partie_imaginaire()+c2.partie_imaginaire());
     return c;
}
 
Complexe operator*(Complexe c1, Complexe c2){
     Complexe c;
     c.enregistre(c1.module()*c2.module(), c1.argument()+c2.argument());
     return c;
}
 
void Complexe::affiche(){
     cout<<"("<<partie_reelle()<<","<<partie_imaginaire()<<")"<<endl;
}
Cartesien.hpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#ifndef CARTESIEN_HPP
#define CARTESIEN_HPP
 
#include "Complexe.hpp"
 
class Cartesien:public Complexe{
public:
 
  Cartesien(double,double);
  virtual void enregistre(double,double);
  virtual double partie_reelle();
    virtual double partie_imaginaire();
    virtual double module();
  virtual double argument();
};
 
#endif
Cartesien.cpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "Cartesien.hpp"
 
#include <math.h>
 
#define PI 3.1411592654
 
using namespace std;
 
Cartesien::Cartesien(double _X, double _Y){
  X = _X;
  Y = _Y;
}
 
double Cartesien::partie_reelle(){
     return X;
}
 
double Cartesien::partie_imaginaire(){
     return Y;
}
 
double Cartesien::module(){
     return sqrt(X*X + Y*Y);
}
 
double Cartesien::argument(){
     double resultat;
     if(X==0)
     {
         if(Y>=0)
             resultat=PI/2;
         else
             resultat=(-PI)/2;
     }
     else
     {
         if(X>0)
             resultat=atan(Y/X);
         else
             resultat=atan(Y/X)+PI;
     }
     return resultat;
}
 
void Cartesien::enregistre(double _X,double _Y){
  X = _X;
  Y = _Y;
}
Polaire.hpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef POLAIRE_HPP
#define POLAIRE_HPP
 
#include "Complexe.hpp"
 
class Polaire:public Complexe{
public:
  Polaire(double,double);
  virtual void enregistre(double,double);
  virtual double partie_reelle();
    virtual double partie_imaginaire();
    virtual double module();
  virtual double argument();
};
 
#endif
Polaire.cpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include "Polaire.hpp"
 
#include <math.h>
 
#define PI 3.1411592654
 
using namespace std;
 
Polaire::Polaire(double _rho, double _teta){
  rho=_rho;
  teta=_teta;
}
 
double Polaire::module(){
     return rho;
}
 
double Polaire::argument(){
     return teta;
}
 
double Polaire::partie_reelle(){
     return rho * cos(teta);
}
 
double Polaire::partie_imaginaire(){
     return rho * sin(teta);
}
 
void Polaire::enregistre(double _rho,double _teta){
  rho = _rho;
  teta = _teta;
}
main.cpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "Cartesien.hpp"
#include "Polaire.hpp"
#include "Complexe.hpp"
 
int main(){
  Polaire p(6,10);
  p.affiche();
  p.enregistre(13,5);
  p.affiche();
  Cartesien C1(1,2);
    Cartesien C2(3,4);
    Cartesien C3=C1+C2;
    C3.affiche();
    Cartesien C4=C1*C2;
    C4.affiche();
    Polaire P1(1,2);
  Polaire P2(2,1);
  Polaire P3=P1+P2;
  P3.affiche();
  Polaire P4=P1*P2;
  P4.affiche();
  return 0;
}
Merci d'avance.