[débutant]classe abstraite et surcharge d'operateur
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:
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:
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:
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:
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:
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:
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:
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.
