Discussion :

[Biosox]

Bonjour.

J'ai crée une classe "Point" (un point = 2 coordonnées) juste dans le but d'essayer de faire des surcharge d'opérateurs et de comprende un peu comment tout cela fonctionne.

Sans rentrer dans les détails de la classe, mon but est de pouvoir surcharger l'opérateur "=" de façon a faire une copie d'un Point. J'ai d'abord écrit une fonction "equals" de manière normale, et je l'ai ensuite modifée pour surcharger "=". Problème: ma fonction "equals" fonctionne, mais pas mon opérateur "=":

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
 
//temp
Point* Point::equals(Point* p)
{
  delete this;
  Point* temp = new Point(p);
  return temp;
}
 
//operators:
Point* Point::operator=(Point* p)
{
  delete this;
  Point* temp = new Point(p);
  return temp;
}

et dans mon main:

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
 
int main(void)
{
  Point* p1 = new Point(2,3); // p1 = (2,3)
  Point* p2 = new Point();     // p2 = (0,0)
  Point* p3 = new Point();     // p3 = (0,0)
 
  p2->equals(p1);                // p2 = (2,3)
  p3 = p1;                          // p3 = (2,3)
 
  p1->SetXY(10,10);            // ERREUR: ça modifie p1 ET p3.
  // donc p3 n'est pas une "deep copy" de p1, mais juste un "alias".
  // pourquoi???
 
  return 0;
}

Que dois-je modifier à ma fonction "equals" pour en faire un opérateur "=" qui ait le même comportement, et que n'ais-je pas compris?

Merci

[Eusebe]

M'étonnes que ça marche ton code...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Point* temp = new Point(p);

Ca ne serait pas plutôt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Point* temp = new Point(*p);

??
Le constructeur par copie prend en paramètre une référence sur un objet, et pas un pointeur sur un objet...

Et pour ton problème, quand tu fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p3 = p1;

Tu affectes p1 à p3. Mais p1 et p3 sont des pointeurs, pas des objets ! Donc tu affectes l'adresse de p1 à p3. Normal qu'à la fin ce soit la même chose.

Pour appeler l'opérateur d'affectation, tu dois faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*p3 = *p1;

C'est à dire 'dépointer' tes pointeurs... Là, c'est l'objet pointé par p3 qui est "affecté" de l'objet pointé par p1.

[Biosox]

Et pour ton problème, quand tu fais

Tu affectes p1 à p3. Mais p1 et p3 sont des pointeurs, pas des objets ! Donc tu affectes l'adresse de p1 à p3. Normal qu'à la fin ce soit la même chose.

Pour appeler l'opérateur d'affectation, tu dois faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*p3 = *p1;

C'est à dire 'dépointer' tes pointeurs... Là, c'est l'objet pointé par p3 qui est "affecté" de l'objet pointé par p1.

Merci, c'était effectivement ça l'erreur.

Par contre pour le "constructeur par copie", il fonctionne.
Je l'ai définiti comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
  Point(Point* p)
  {
    this->x = p->x;
    this->y = p->y;
  }

Est-ce qu'il y a quelque chose de mal la dedans?
merci

[Bakura]

Merci, c'était effectivement ça l'erreur.

Par contre pour le "constructeur par copie", il fonctionne.
Je l'ai définiti comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
  Point(Point* p)
  {
    this->x = p->x;
    this->y = p->y;
  }

Est-ce qu'il y a quelque chose de mal la dedans?
merci

Oui c'est bon,... Je te conseille d'utiliser ça comme ça :

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
#include <iostream>
using namespace std;
 
class Point
{
   public:
      Point (int x = 0, int y = 0) {iX = x, iY = y;}
      Point (const Point &);
      ~Point () {};
 
      Point & operator= (const Point &);
 
      int iX, iY;
};
 
Point::Point (const Point & p)
{
   iX = p.iX;
   iY = p.iY;
}
 
Point & Point::operator= (const Point & droite)
{
   this->iX = droite.iX;
   this->iY = droite.iY;
 
   return *this;
}
 
int main()
{
	Point p1 (2, 3); // (2, 3)
	Point p2 (p1); // (2, 3) aussi
 
	Point p3 = p2; // (2, 3);
 
	return 0;
}

[Eusebe]

Par contre pour le "constructeur par copie", il fonctionne.
Je l'ai définiti comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
  Point(Point* p)
  {
    this->x = p->x;
    this->y = p->y;
  }

Est-ce qu'il y a quelque chose de mal la dedans?
merci

Ben, c'est juste que ce n'est pas 'vraiment' le construteur par copie.
Le constructeur par copie prend en paramètre une référence sur un objet (ou sur un objet constant).
Et donc, dans ton cas, comme tu ne définis pas de constructeur par copie, il est toujours créé par le compilateur...

[Matthieu Brucher]

Ton code est... comment dire... à éviter comme la peste ?
Attention à bien savoir ce que tu manipules, il y a une différence entre instance et pointeur vers une instance, et les méthodes appelées seront différentes selon les cas.
Dans ton cas, pour un pointeur, tu ferais mieux d'utiliser directement les objets et pas des pointeurs.

[Luc Hermitte]

Patch pour le code de bakura : l'opérateur d'affectation est censé renvoyé une référence non constante.

NB: vu que ton point ne semble contenit que des entiers, inutile d'écrire les deux opérations de recopie. Celles fournies par défaut suffisent et sont parfaitement efficaces.

PS: Une classe comme un point a typiquement une sémantique de valeur, et est à deux doigts de disposer de son algèbre -- à voir comment tu t'en serviras. Autrement dit, les manipuler via des pointeurs n'est pas du tout adapté. C'est très "Java" comme façon de faire.