Classe Point3D (constructeurs, surcharges d'opérateurs etc.)

Version imprimable

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:

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:

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:

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 ?

Salut,
Citation:
Envoyé par Jéjé34
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:

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; }
D'accord, si tu me dis quel est le comportement attendu par C(B+5)...

Faut il que ce soit c.x, c.y ou c.z qui prenne une valeur égale à 5 de plus que la valeur correspondante de B :question:
J'ai fait cela :
Citation:
Code:

1 2 #include <iostream> using namespace std;
Ne JAMAIS de directive using namespace dans un fichier d'en-tête!!!

Et surtout pas si la directive parle de std ;)

Les espaces de noms sont prévus pour éviter les conflits entre les bibliothèques.

En placant une directive using namespace std; dans un fichier d'en-tête, tu ne sais jamais jusqu'où cette directive pourra se propager, et cela risque fort de te poser problème le jour où tu voudras créer une classe ou une fonction qui porte le même nom qu'une classe ou qu'une fonction issue de l'espace de noms std ;)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Point3D { private: double x, y, z; public : Point3D(); Point3D(double, double, double); Point3D(const Point3D&); // inutile!!! ~Point3D(); // inutile!!! double getX() const; double getY() const; double getZ() const; void setX(double); // inutile et aberrant !!! void setY(double); // inutile et aberrant !!! void setZ(double); // inutile et aberrant !!! ostream& affiche(ostream& os) const; // pour quoi faire ??? istream& saisie(istream& is); // pour quoi faire ??? };
Le compilateur est tout à fait en mesure de fournir quatre fonctions particulières lorsqu'on ne lui donne "aucune raison de ne pas le faire".

C'est fonctions sont:

Un constructeur trivial (ne prenant aucun argument)
le constructeur par copie
l'opérateur d'affectation
le destructeur

Les comportements par défaut sont clairement établi, ce qui fait que

Le contructeur trivial se contentera d'appeler le (pseudo) constructeur des membres de la classe dans l'ordre dans lequel les différents membres sont déclarés
le constructeur par copie appelle les constructeur par copie des différents membres dans l'ordre de leur déclaration
L'opérateur d'affectation affectera les bonnes valeurs aux bons membre et renverra une référence sur l'objet courent
le destructeur détruira les membres de la classe dans l'ordre inverse de leur déclaration

Il faut "juste" savoir que le compilateur ne fournira pas d'implémentation du constructeur trivial s'il trouve une autre déclaration de constructeur ;)

Si ces comportements correspondent à ce que tu veux (en gros, dés le moment où ta classe a sémantique de valeur et où tu ne travailles pas avec des pointeurs pour lesquels il faudrait gérer la mémoire de manière dynamique), il ne sert à rien de s'em...der à déclarer et à implémenter ces différentes fonctions : autant laisser faire le compilateur, car cela fait des risques d'erreur en moins ;)

Par contre, il est vrai que si tu décides de redéfinir l'une des trois dernières fonctions (constructeur par copie, opérateur d'affectation ou destructeur), tu devras très certainement redéfinir les trois ;)

Dans le cas présent, tu pourrais très bien laisser le compilateur générer lui-même le constructeur par copie, l'opérateur d'affectation et le destructeur (car il ne font rien d'autre que ce que fait l'implémentation que le compilateur fournirait ;))

Si je qualifie les mutateurs (setX, setY et setZ) "d'inutiles et aberrant", c'est pour plusieurs raisons:

D'abord parce que le débat concernant l'encapsulation à tout prix est loin d'être cloturé, et qu'on peut clairement se poser la question de l'intérêt qu'il y a à déclarer un membre comme étant privé si c'est, d'un autre coté, pour permettre à l'utilisateur de le modifier à sa guise.

Ensuite parce que, à moins de vouloir déplacer le point vers une coordonnée bien précise, on risque fort d'avoir besoin... de l'accesseur (getX, getY ou getZ) correspondant pour pouvoir déterminer la nouvelle coordonnée.

Enfin, et surtout, parce qu'une classe Point3D a, typiquement, sémantique de valeur:

C'est une classe pour laquelle il est tout à fait possible de trouver différentes instances (clairement différentes) présentant des valeurs strictement similaires et pour laquelle, si l'on modifie ne serait-ce qu'un tout petit peu une des données, nous obtenons... un autre point (à la précision que l'on souhaite garder afin d'estimer que c'est le même point près ;)).

Enfin (du moins, pour la première partie de code), si je te demande pour quoi faire au sujet des fonctions affiche et saisie, c'est parce que tu t'amuse là à créer deux fonctions qui auront strictement le même résultat que les opérateur << et >>.

Je crois te l'avoir déjà dit: nous ne sommes ni en java ni en C#, mais en C++, et il n'y a strictement aucun problème à utiliser une fonction libre avec une instance de classe ;)

Le seul cas dans lequel il serait sans doute opportun de créer ces deux fonctions serait le cas où la classe a sémantique d'entité, et où il faudrait pouvoir définir un comportement polymorphe.

Mais cela impliquerait que affiche et saisie soient déclarées virtuelles et, comme je te l'ai fait remarquer plus haut, ta classe a typiquement sémantique de valeur, ce qui disqualifie ta classe pour l'héritage ;)
Citation:
Code:

1 2 3 4 5 6 #include "Point3D.h" Point3D::Point3D(const Point3D& p) { x = p.x; y = p.y; z = p.z; }
Tant qu'à le définir, pourquoi ne pas utiliser les listes d'initialisation, comme pour le constructeur "normal" :question:
Il prendrait alors la forme de

Code:

Point3D::Point3D(Point3D const & p):x(p.x),y(p.y),z(p.z){}
Citation:
Code:

1 2 3 4 5 6 7 8 ostream& operator<<(ostream& os, const Point3D& p) { return p.affiche(os); } istream& operator>>(istream& is, Point3D& p) { return p.saisie(is); }
En déclarant les opérateurs << et >> ami de ta classe, tu aurais pu t'éviter l'écriture des fonctions affiche et saisie ;)
Citation:
Code:

1 2 3 4 5 6 7 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; }
Déjà, il n'y a aucune raison de transmettre un type primtiif (int en l'occurence) sous la forme d'une référence constante... Cela ne sert strictement à rien

Ensuite, que penserais tu de
Code:

1 2 3 4 5 Point3D operator+(const Point3D& p, const int&i) { Point3D resultat(p.getX() + i, p.getY() + i, p.getZ() + i); return resultat; }
A moins que ce ne soit
Code:

1 2 3 4 Point3D operator+(const Point3D& p, const int&i) { Point3D resultat(p.getX() + i, p.getY(), p.getZ() ); return resultat; }
ou
Code:

1 2 3 4 Point3D operator+(const Point3D& p, const int&i) { Point3D resultat(p.getX(), p.getY() + i, p.getZ()); return resultat; }
ou encore
Code:

1 2 3 4 Point3D operator+(const Point3D& p, const int&i) { Point3D resultat(p.getX(), p.getY(), p.getZ() + i); return resultat; }
:question:

Ce qu'il faut comprendre, c'est que l'opérateur + a une sémantique bien à lui, que l'on retrouve dans 3+4 , "salut "+"monde" ou meme pour les vecteurs et les matrices.

Par contre, l'opérateur + est pour le moins ambigu lorsqu'il s'agit de parler d'un point :aie:

Il ne devrait donc pas être utilisé dans ce cadre ;)
Citation:
Code:

1 2 3 4 5 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())); }
Même remarques que pour l'opérateur +

Citation:

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.

Et tu peux rajouter l'opérateur d'affectation dans le lot: tous trois sont, comme je te l'indiquais plus haut, totalement inutiles dans le cas présent ;)

Citation:

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 ?

A mon sens, ils ne devraient pas exister du tout car beaucoup trop ambigu quant à leur comportement ;)

Je n'ai aucune idée du comportement des opérateurs + et - ...
La seule chose que je sais c'est qu'il doivent être présent pour que le programme compile correctement.
Du coup, j'ai choisis les comportements qui paraissaient les plus logiques à mes yeux.

En fait, je suis en train de me préparer a mon examen en faisant des exercices des années passés, et ici on me demande de faire marcher le programme suivant, tout simplement :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #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; }
...sans aucune autre information sur le comportement des opérateurs.

A l'origine, je dois seulement écrire la signature de la classe et des fonctions associés, mais je me suis amusé à faire le .cpp.

Pour ce qui est de l'using namespace dans un fichier d'en-tête et des setteurs, je ne savais pas, c'est noté. :ccool:

Quant à l'inutilité de mon constructeur par copie et de mon destructeur, je m'en doutais un petit peu, m'en voila certain maintenant. :aie:

Enfin, a propos de de mes fonctions saisie et affiche, c'est une solution que nous avons vu en cours...
Nous n'avons pas encore vu la notion d'amitié, ceci explique peut-être cela.

Je tiens en tout cas à te remercier pour tes réponses très complètes et pédagogiques. :ccool:

Citation:

Envoyé par Jéjé34

Je n'ai aucune idée du comportement des opérateurs + et - ...

C'est bien ce que je reproche!!!

Mais je ne sais pas si je dois te le reprocher à toi ou au sagouin qui a pondu l'exercice :D

Citation:

La seule chose que je sais c'est qu'il doivent être présent pour que le programme compile correctement.

Je sais surtout que l'exercice est aberrant étant donné que la sémantique de l'opérateur + n'est pas correctement dérfinie :D

Citation:

Du coup, j'ai choisis les comportements qui paraissaient les plus logiques à mes yeux.

Je ne suis pas sur que le comportement que tu as choisi soit vraiment plus logique que les trois autres que j'ai proposés :D
Citation:
En fait, je suis en train de me préparer a mon examen en faisant des exercices des années passés, et ici on me demande de faire marcher le programme suivant, tout simplement :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #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; }
...sans aucune autre information sur le comportement des opérateurs.
Moralité : le prof est un imbécile fini (oui, tu peux le lui répéter de ma part :D)

Si il veut que le programme compile et s'exécute correctement, qu'il commence d'abord par préciser la sémantique qu'il s'attend à retrouver pour l'opérateur + ;)

Citation:

A l'origine, je dois seulement écrire la signature de la classe et des fonctions associés, mais je me suis amusé à faire le .cpp.

C'est tout à ton honneur, le problème, c'est que l'exercice est insoluble en l'état (en tout cas, dés qu'il faut fournir l'implémentation), ou du moins, pour ce qui concerne la déclaration de C ;)

Citation:

Enfin, a propos de de mes fonctions saisie et affiche, c'est une solution que nous avons vu en cours...
Nous n'avons pas encore vu la notion d'amitié, ceci explique peut-être cela.

Je tiens à préciser que ta solution n'est pas à proprement parler mauvaise.

Cependant, elle ne devrait être utilisée que si tu as besoin d'un comportement polymorphe (car l'opérateur << ne peut pas être virtuel).

Autrement, elle ne fait que t'obliger à rajouter deux fonctions qui font double emploi ;)

Citation:

Je tiens en tout cas à te remercier pour tes réponses très complètes et pédagogiques. :ccool:

Mais de rien ;)

Et pourtant je viens de faire un exercice du même genre encore plus abberant. :mrgreen:
Citation:
Ecrire le fichier Inconnu.h de manière à ce que le programe suivant compile correctement (pas d'édition de lien). Attention, vous n'avez besoin d'écrire que les signatures des méthodes et des fonctions. Tout code inutile sera pénalisé.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <iostream> #include "Inconnu.h" using namespace std; int main() { int T[3] = {1, 1, 2000}; Inconnu d1 (12, 1, 2008); Inconnu d2(T); Inconnu d3[2]; cin >> d3[0] >> d3[1]; cout << d3[0] << d3[1] << endl; cout << 17+d1+d2 << endl; return 0; }
A partir du programme, j'ai déduit que Inconnu était surement une classe qui contenait 3 attributs de type int.

Avec 3 constructeurs: un constructeur vide, un constructeur qui prend 3 arguments de type int, et un constructeur qui prend un argument qui est un tableau de 3 entiers.

Pour ce qui est des opérateurs, du classique pour la saisie et l'affichage...
(j'ai utilisé la méthode qu'on a vu en cours, mais après ce que tu m'as dit, je suis bien conscient que ce n'est pas la meilleure, ni la plus judicieuse)

Quant au comportement de l'opérateur +, n'ayant aucune information dans l'énoncé sur la sémantique de la classe Inconnu, j'ai décidé de lui faire prendre un entier et un objet Inconnu en paramètre de tel sorte que le résultat soit : l'entier + somme des 3 attributs.
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 #include <iostream> class Inconnu { private : int a, b, c; public : Inconnu(); Inconnu(int, int, int); Inconnu(int[3]); int getA() const; int getB() const; int getC() const; istream& saisie (istream&); ostream& affiche (ostream&) const; }; istream& operator>>(istream&, Inconnu&); ostream& operator<<(ostream&, const Inconnu&); int operator+(int, const Inconnu&);
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 #include "Inconnu.h" #include <iostream> using namespace std; Inconnu::Inconnu(): a(0), b(0), c(0) { } Inconnu::Inconnu(int x, int y, int z): a(x), b(y), c(z) { } Inconnu::Inconnu(int T[3]): a(T[0]), b(T[1]), c(T[2]) { } int Inconnu::getA() const { return a; } int Inconnu::getB() const { return b; } int Inconnu::getC() const { return c; } istream& Inconnu::saisie(istream& is) { return is >> a >> b >> c; } ostream& Inconnu::affiche(ostream& os) const { return os << "(" << a << ", " << b << ", " << c << ")" << endl; } istream& operator>>(istream& is, Inconnu& in) { return in.saisie(is); } ostream& operator<<(ostream& os, const Inconnu& in) { return in.affiche(os); } int operator+(int i, const Inconnu& in) { return (i + in.getA() + in.getB() + in.getC()); }