surcharge operateur =

Version imprimable

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:

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:

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

31/08/2006, 12h20
Eusebe

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

Citation:

Code:

Point* temp = new Point(p);

Ca ne serait pas plutôt

Code:

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

Citation:

Code:

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:

*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.
31/08/2006, 12h28
Biosox
Citation:

Envoyé par Eusebe

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:

*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.:oops:

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

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

Citation:

Envoyé par Biosox

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

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

Code:

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:

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;
}

31/08/2006, 13h28
Eusebe
Citation:
Envoyé par Biosox

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

Code:

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...
31/08/2006, 14h06
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.
31/08/2006, 14h32
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.
31/08/2006, 14h39
Bakura

Citation:

Envoyé par Luc Hermitte

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

Ok c'est corrigé ^^... Par contre,... pourquoi ? :lol: a = b = c... Il a pas besoin d'être modifié, pourquoi ne pas déclarer le retour constant ?
31/08/2006, 14h41
Médinoc

Pour autoriser (a = b)++; par exemple.
31/08/2006, 14h43
Bakura

Citation:

Envoyé par Médinoc

Pour autoriser (a = b)++; par exemple.

Ah ok... Mais c'est assez tarabiscoté comme expression ça :lol:

Oui, il y a plus simple en effet, mais plus long :

Code:

1
2
3
4
5
6
7
8
9
10
void UneFonction(CUneClasse &obj);
 
void UneAutreFonction(void)
{
CUneClasse a(blablabla);
CUneClasse b;
 
//...
UneFonction(b = a);
}

31/08/2006, 16h11
Biosox
Citation:

Envoyé par Luc Hermitte

C'est très "Java" comme façon de faire.

ça m'étonne pas. J'ai appris a programmer avec Ada et C, et j'ai appris la POO avec Java.

Je me suis dit: Je connais C (enfin... existe-t-il vraiment quelqu'un qui puisse dire "je connais C" ?), je connais Java, C++ ce sera juste un gros mélage des 2.

Et ben non. Le problème c'est que j'ai pas à disposition assez de temps pour me plonger correctement dans l'apprentissage de C++, alors j'essaye de digérer les concepts a la vitesse "grand V".

Merci a vous tous d'avoir pris le temps de me donner un coup de main.
Je savais même pas qu'on pouvait faire:
Point p1(2,3)
Pour moi, pour créer un nouvel objet de ma classe Point, je DEVAIS écrire un "new" quelque part... d'ou les pointeurs un peu partout.
Par contre, j'ai changé mon main en:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int main(void) { Point p1(2,3); Point p2; p2 = p1; p1.SetXY(10,10); return 0; }
Et je ne comprend pas pourquoi ça marche.
(ça marche, j'ai bien p2 = (2,3), et seul p1 est modifié par SetXY)
J'ai pas changé mon
Code:

1 2 3 4 5 6 7 Point* Point::operator=(Point* p) { delete this; Point* temp = new Point(p); return temp; }
Donc dans mon main, mon "p2 = p1" ne fait pas appel à "mon" opérateur "=", si?

La je m'y perds...

EDIT:
j'ai modifié:
Code:

1 2 3 4 5 Point Point::operator=(Point p) { this->SetXY(p.x,p.y); return this; }
Et ça marche toujours, mais pourquoi ça marchait avant???
31/08/2006, 16h21
Eusebe

Parce que l'opérateur d'affectation est automatiquement défini par le compilateur.

C'est une simple recopie membre à membre de ton objet. Et comme tes membres sont des types copiables, ça fonctionne tout seul.

En fait, dans ton cas, comme le signale Luc, la réécriture de l'opérateur d'affectation et du constructeur par copie sont inutiles...
31/08/2006, 16h36
Biosox

Mais dans le fond, si je comprend bien, en C++, l'utilisation du "new" se fait la ou on utiliserai un "malloc" en C (c'est-à-dire: le moins souvent possible)
J'ai juste?
(Je commence à comprendre pourquoi mon code était à éviter comme la peste).

Je ne met pas encore résolu, car je vais me lancer dans la surcharge de l'opérateur+ maintenant... je mettrai résolu si ça marche.

en tout cas MERCI!
31/08/2006, 16h39
Laurent Gomila

Citation:

Mais dans le fond, si je comprend bien, en C++, l'utilisation du "new" se fait la ou on utiliserai un "malloc" en C (c'est-à-dire: le moins souvent possible)
J'ai juste?
(Je commence à comprendre pourquoi mon code était à éviter comme la peste).

Dans les grandes lignes c'est ça, oui.
31/08/2006, 16h59
Luc Hermitte
En plus des expressions tarabiscotés, que l'on supporte par compatibilité ascendante avec le C -- si j'ose dire--, si l'opérateur d'affectation renvoie bien une référence non-constante, alors on est assuré que seul *this puisse être renvoyé de la sorte.
Bref, c'est une convention.

Si tu en as l'occasion, je ne peux que te conseiller d'investir dans une ressource qui te montre le C++ sans pré-requis autre que des notions d'algorithmique -- je pense p.ex. à Accelerated C++. Si tu pars de tes bases C et Java, tu vas perdre un peu de temps à réinventer des trucs qui seront les trois-quart du temps bancals.

Autrement. Dans un premier temps : ne jamais faire de "delete this". (Il y a quelques cas où c'est interessant, mais pas là, pas quand on débute)

La signature

Code:

Point* Point::operator=(Point* p)

ne sera utilisé que si tu affectes un pointeur (vers une donnée non constante!!) à ton objet :
Code:

1 2 3 4 5 point * p1 = new Point(42,43); *p1 = new Point(12,14); // fuite de mémoire Point p3(24,18); *p1 = &p3; p3 = p1;
Bref, ce n'est pas du tout fait pour être utilisé de la sorte. La copiabilité, en C++, marche avec des valeurs. Pas avec des entités. Java n'a que des entités pour les types customs. On ne fait pas des cabrioles non plus pour tester l'égalité.

En général, je me sers explicitement du new en C++ pour gérer des entités et autres données aux cycles de vie "étendus" -- le bon mot ne me vient pas.
31/08/2006, 17h07
loufoque

Pourquoi y'a des pointeurs partout ?
Pourquoi tu fais delete this ? (ça devrait même pas être autorisé ça d'ailleurs)

Citation:

(enfin... existe-t-il vraiment quelqu'un qui puisse dire "je connais C" ?)

Oui. Soyons honnêtes, C est un langage extremement simple (si on fait abstraction de certains détails qui sont un peu délicats niveau syntaxe), mais très lourd à utiliser.
Ce qui est exactement le contraire de C++, qui est agréable à utiliser mais très sophistiqué.

Citation:

je connais Java, C++ ce sera juste un gros mélage des 2.

Une des différences avec Java c'est la gestion mémoire.
En Java, tous les objets sont alloués dynamiquement et on ne manipule que des références vers eux, et la mémoire et gérée par un ramasse-miettes.
En C++, les objets sont alloués sur la mémoire locale, la pile, qui dispose d'une gestion automatique en fonction des blocs. Les objets sont alors manipulés par des sémantiques de copie. Bien sûr, il est aussi possible d'utiliser des pointeurs vers ces objets ou d'en allouer dynamiquement, mais dans ce dernier cas la mémoire n'est pas libérée automatiquement.
Tu remarqueras aussi une différence pour le polymorphisme. Tu ne peux considérer un objet de type dérivé comme si c'était un type de base que via un pointeur ou une référence.

Normalement, ta classe Point devrait être triviale.
Par conséquent tu n'as même pas à redéfinir le constructeur par copie ni l'operateur d'affectation.
31/08/2006, 20h30
koala01
Salut,

Pour que tu puisse bien comprendre le principe des classes, on pourrait dire qu'il ne s'agit d'une structure (les typedef struct ... du C), avec juste un petit plus.

De même qu'en C, tu n'est pas obligé d'utiliser l'allocation dynamique sur les structure "simples" (on va plutot écrire: "sur les structure composées uniquement de type de base" ;)), tu n'est pas *forcément* obligé de l'utiliser pour les classes du C++

En C, tu aurais un code du genre de
Code:

1 2 3 4 5 6 7 8 9 typedef struct SPoint { int x; int y; }Point; // et dans le code Point MonPoint; MonPoint.x=12; MonPoint.y=15;
en C++, tu n'aurais "que" l'abstraction en plus en créant une classe sous la forme de
Code:

1 2 3 4 5 6 7 8 9 class Point { public: int x; int y; }; //et dans le code Point MonPoint(12,15);
Il est d'ailleurs à noter que les classes et les structures peuvent etre utilisée exactement de la meme manière en C++ (héritage, définition de méthodes...).

La seule différence étant qu'une structure aura un héritage, des membres et des méthodes publiques par défaut, alors que les classes les auront en privé par défaut (AKA: si on n'indique pas protected: ou public avant les membres/méthodes définies)

On peut terminer en citant le fait que les opérateurs binaires classiques, si l'on veut les surcharger, utilisent toujours les références, pour éviter la création de variables temporaires (entre autres)