Bonjour,

Je suis en train de faire l'exercice suivant :

Je dois écrire une classe Point3D qui doit être conçu de telle manière que la programme suivant compile correctement :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
#include "Point3D.h"
#include <iostream>
 
using namespace std;
 
int main() {
  Point3D A, B(2.3, 1.8, 44.5), C(B+5);
  cin >> A;
  cout << A << B << C << endl;
  cout << "La distance entre A et B est : " << A - B << endl;
  return 0;
 
}
J'ai fait cela :

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
#include <iostream>
using namespace std;
 
class Point3D {
 
 private: 
  double x, y, z;
 
 public :
  Point3D();
  Point3D(double, double, double);
  Point3D(const Point3D&);
  ~Point3D();
 
  double getX() const;
  double getY() const;
  double getZ() const;
 
  void setX(double);
  void setY(double);
  void setZ(double);
 
  ostream& affiche(ostream& os) const;
  istream& saisie(istream& is);
 
};
 
ostream& operator<<(ostream& os, const Point3D& p);
istream& operator>>(istream& is, Point3D& p);
 
Point3D operator+(const Point3D&, const int&);
double operator-(const Point3D&, const Point3D& p);
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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include "Point3D.h"
#include <iostream>
#include <cmath>
 
using namespace std;
 
Point3D::Point3D(): x(0), y(0), z(0) { }
 
Point3D::Point3D(double x, double y, double z): x(x), y(y), z(z) { }
 
Point3D::Point3D(const Point3D& p) {
  x = p.x;
  y = p.y;
  z = p.z;
}
 
Point3D::~Point3D() { }
 
double Point3D::getX() const {
  return x;
}
 
double Point3D::getY() const {
  return y;
}
 
double Point3D::getZ() const {
  return z;
}
 
void Point3D::setX(double x){
  this->x = x;
}
 
void Point3D::setY(double y) {
  this->y = y;
}
 
void Point3D::setZ(double z) {
  this->z = z;
}
 
ostream& Point3D::affiche(ostream& os) const {
  return os << "(" << x << ", " << y << ", " << z << ")" << endl;
}
 
istream& Point3D::saisie(istream& is) {
  return is >> x >> y >> z;
}
 
ostream& operator<<(ostream& os, const Point3D& p) {
  return p.affiche(os);
}
 
istream& operator>>(istream& is, Point3D& p) {
  return p.saisie(is);
}
 
Point3D operator+(const Point3D& p, const int&i) {
  Point3D resultat;
  resultat.setX(resultat.getX() + p.getX() + i);
  resultat.setY(resultat.getY() + p.getY() + i);
  resultat.setZ(resultat.getZ() + p.getZ() + i)
  return resultat;
}
 
double operator-(const Point3D& a, const Point3D& b) {
  return sqrt ((a.getX() - b.getX()) * (a.getX() - b.getX())
	       + (a.getY() - b.getY()) * (a.getY() - b.getY())
	       + (a.getZ() - b.getZ()) * (a.getZ() - b.getZ()));
}
A priori ça à l'air de fonctionner mais j'aimerai quand même avoir votre avis d'experts sur tout ça.
J'ai un doute notamment sur l'utilité de mon destructeur et de mon constructeur par copie, puisque je n'ai pas d'attributs dynamiques.
Quant a mes fonctions opérateurs + et -, est t'il judicieux de les avoir mis en dehors de la classe ? Des méthodes n'auraient pas été plus pertinentes ?