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.

[Bakura]

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 ? a = b = c... Il a pas besoin d'être modifié, pourquoi ne pas déclarer le retour constant ?

[Médinoc]

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

[Bakura]

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

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

[Médinoc]

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

Code :

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

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

[Biosox]

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 :

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

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 :

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

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 :

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

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???

[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...

[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!

[Laurent Gomila]

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.

[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 :

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

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

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

Code :

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

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.

[loufoque]

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

(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é.

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.

[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 :

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

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 :

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

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)