Discussion :

[zorm]

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.

[lison1]

bonjour,

quels message d'erreur est affiché? il sera plus facile de t'aider si tu montre quelle est l'erreur !

[zorm]

certes, je peux faire ca
pour les 2 surcharges d'operateurs de complexe.cpp, j'ai le meme probleme du au fait que la classe est abstraite.
Je donne l'exemple pour l'operateur *

[Luc Hermitte]

Tu as une erreur de design.
Tes nombres sont peut-être définis en termes de trucs 2D. Mais ils n'en sont pas vraiment.
De plus, la sémantique de valeur est difficilement compatible avec l'héritage public. Et vu que la sémantique des nombres (avec les opérateurs) étend la sémantique de valeur, tu vas te retrouver coincé.

Si tu veux hériter, c'est de façon privée que cela conviendra mieux. Après, il te faudra rajouter un peu de copier-coller.

PS: tu as déjà du code dupliqué. Sers-toi des constructeurs.

[zorm]

Merci, ca a le merite d'etre pas claire du tout. Je ne comprends absolument pas ce que tu veux dire par là Luc Hermitte

[Luc Hermitte]

Personne pour traduire dans la journée ?
A moins de faire des pirouettes pas possibles, tu n'arriveras jamais manipuler des copies sur des objets tirés de hiérarchies polymorphes. C'est comme ça.

De plus ton héritage confond la notion de "est-un", avec la notion d'"être implémenté en termes de".

Pouf lectures. -> http://www.developpez.net/forums/sho...06#post1602606

[zorm]

Merci pour cette réponse.