retour par référence et new

Version imprimable

Bonjour,
Étant novice dans l'utilisation du retour par référence je me demande ce qui suit:
j'ai une classe (Point3D qui comporte les variables x,y et z ) dont une méthode (ci-bas) effectue un retour par référence d'un Vecteur3D (autre classe). Ma question, dois-je utiliser "delete" comme je le fais actuellement? Merci.
Code:

1 2 3 4 5 6 7 8 9 10 11 // calcules le vecteur entre le point actuel et le point P Vecteur3D & Point3D::operator - ( Point3D P ) { Vecteur3D * Q = new Vecteur3D(); (*Q).x = x - P.x; (*Q).y = y - P.y; (*Q).z = z - P.z; return *Q; delete Q; }

Salut,

je ne comprends pas bien ce que tu veux faire là mais il y a visiblement des problèmes ...

Pourquoi retourner un Vecteur3D quand tu soustrait deux Point3D ? Je vois bien qu'un vecteur est calculé en soustrayant les coordonnées des deux points extrémités mais j'ai du mal à voir les différences, le code des deux classes est-il différent pour devoir séparer les deux ?

En admettant que la classe Vecteur3D soit nécessaire, pourquoi ne pas avoir créé un constructeur qui prend en paramètres les valeurs en x, y et z ?

Enfin pour répondre à ta question, je ne comprends pas pourquoi tu crée un Vecteur3D dynamique, avec ton code, le delete ne sera jamais atteint et l'objet ne sera pas supprimé. Pourquoi vouloir absolument retourner une référence ? Créer un objet non dynamique et le renvoyer ne convient-il pas ?
Code:

1 2 3 4 5 6 // calcule le vecteur entre le point actuel et le point P Vecteur3D Point3D::operator- (const Point3D & P) { Vecteur3D Q(x - P.x, y - P.y, z - P.z); return Q; // on retourne une copie de Q }
On peut faire ça en 1 ligne mais bon, c'est juste un exemple ...

Salut, et bienvenue sur le forum.

D'abord, il faut savoir que, le delete apparaissant après l'instruction de retour, il ne sera jamais effectué (un compilateur "correctement réglé" t'aurait sans doute lancé un avertissement du genre "attention, cette instruction ne sera jamais exécutée" ;))

Cela provoquera donc, au mieux, une fuite mémoie :aie:

Il serait par contreencore pis d'inverser l'ordre sous la forme de
Code:

1 2 delete Q; return *Q;
parce que tu renverrais alors une référence sur... un objet qui a déjà été détruit (ce qui reviendrait donc au même que si tu n'avais simplement pas eu recours à l'allocation dynamique :aie:)

Ensuite, il faut savoir que l'opérateur - ne devrait pas renvoyer une référence, mais un nouvel objet...

Les seuls opérateurs qui renvoient une référence (sur le premier opérande de l'opération) sont ayant une composante d'affectation ( =, +=, -=, *=, /= pour être précis), parce que l'objet résultant est... le premier opérande.

Ainsi, le plus souvent, nous agirons en deux temps:

1- définir l'opérateur ayant une composante d'affectation comme fonction membre de la classe, renvoyant "ce qui est pointé par this" par exemple:
Code:

1 2 3 4 5 6 7 8 9 Vecteur3D & Vecteur3D::operator -=(Vecteur3D const & v) { /* calculer la différence directement sur les membres de this */ x-=v.x; y-=v.y; /*...*/ /* renvoyer l'objet modifié */ return *this; }
2- définir l'opérateur n'ayant pas de composante d'affectation comme fonction libre qui effectue une copie du premier opérande et renvoie le résultat de l'opérateur équivalent ayant composante d'affectation sur cette copie. Par exemple:
Code:

1 2 3 4 5 6 Vecteur3D operator-=(Veceur3D const & v1, Vecteur3D const & v2) { /* copie de v1 */ Vecteur3D temp(v1); return temp-=v2; }

27/05/2010, 13h22
Fabllot
Bonjour,

Philosophiquement parlant:

Citation:

Envoyé par myzu69

Pourquoi retourner un Vecteur3D quand tu soustrait deux Point3D ? Je vois bien qu'un vecteur est calculé en soustrayant les coordonnées des deux points extrémités mais j'ai du mal à voir les différences, le code des deux classes est-il différent pour devoir séparer les deux ?

Mathématiquement, un point et un vecteur sont deux choses bien différentes... On peut donc penser qu'un certain nombre de méthodes soient proposées pour une classe mais pas pour l'autre... N'ayant pas le détail de ces classes, je pense qu'on ne peut juger un tel point.

Informatiquement parlant:

Citation:

En admettant que la classe Vecteur3D soit nécessaire, pourquoi ne pas avoir créé un constructeur qui prend en paramètres les valeurs en x, y et z ?

Un certain nombre d'APIs et de conventions de codage recommande de limiter les paramètres des constructeurs, et de préferer les passages par 'set' ou par des méthodes d'initialisations... Sa manière d'initialiser ses variables n'est donc pas choquante.

Citation:

Enfin pour répondre à ta question, je ne comprends pas pourquoi tu crée un Vecteur3D dynamique, avec ton code, le delete ne sera jamais atteint et l'objet ne sera pas supprimé.

Totalement d'accord, il y a une fuite de mémoire inquiétante...

Citation:

Pourquoi vouloir absolument retourner une référence ? Créer un objet non dynamique et le renvoyer ne convient-il pas ?

Pour jouer l'avocat du diable, renvoyer une copie peut être couteux... On ne sait pas ce que contient sa classe... Bon là, j'avoue qu'a priori il n'y a que trois nombres à copier, mais par principe je trouve cela moyen...

Autre question de principe (j'en ai beaucoup!), je trouve dangeureux dans une opération de soustraction que le résultat soit de type différent des paramètres d'entrée...
Si on a que des éléments du même type voir les solutions de koala01 sinon passer par une méthode avec un nom spécifique du type :
Code:

1 2 3 Vecteur3D* Point3D::CreerVecteurAvec (const Point3D& P); // ou sans doute mieux: bool Point3D::CreerVecteurAvec (const Point3D& P, Vecteur& V);
Finish:

Citation:

Envoyé par myzu69

On peut faire ça en 1 ligne mais bon, c'est juste un exemple ...

ça c'est pas un argument !
27/05/2010, 13h36
3DArchi

Bonjour et bienvenu,
Quelques éléments complémentaires :
Strictement parlant, référence ou pointeur : il faut faire attention à la durée de vie de l'objet désignée. Si tu retourne un référence ou un pointeur qui est détruit en fin de fonction (soit explicitement avec ta tentative de delete, soit implicitement sur une variable locale à ta fonction), ta référence ou ton pointeur sont invalides et leur utilisation est indéterminée (généralement un crash au bout d'un moment).
@fallbot : (pour jouer l'avocat du contre-diable ;)) un retour par valeur avec une fonction comme Vecteur3D Point3D::CreerVecteurAvec (const Point3D& P)const;, avec un peu de chance, sera optimisé en (N)RVO évitant la copie.
27/05/2010, 14h02
Fabllot

Citation:

Envoyé par 3DArchi

@fallbot : (pour jouer l'avocat du contre-diable ;)) un retour par valeur avec une fonction comme Vecteur3D Point3D::CreerVecteurAvec (const Point3D& P)const;, avec un peu de chance, sera optimisé en (N)RVO évitant la copie.

Un peu de rigueur que diable ! :D

Bonjour,
En ce qui me concerne, je procède de cette façon là

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
Point3D *P1; // Un pointeur sur un objet existant
Point3D *P2; 
// Maintenant, un veut créer un vecteur V
// le but étant naturellement de l'utiliser, par exemple pour le comparer
// à un autre vecteur   
  Vecteur3D *V1=new Vecteur3D(P1, P2);
  ... // traitement
  delete V1;
 
// La classe Vecteur3D
class Vecteur3D
{
  float a, b, c;
public:
  Vecteur3D {Point3D *p1, Point3D *p2)
  {
    a=p2->x - p1->x;
    b=p2->y - p1->y;
    c=p2->z - p1->z;
  }
};

27/05/2010, 21h07
3DArchi

Quel est l'intérêt de l'allocation dynamique ?
Et quel est l'intérêt de passer les paramètres par pointeur ? En plus il n'y a pas de prise en compte de la constance. Perso, quand je passe un pointeur, c'est que la fonction peut accepter NULL. Si ce n'est pas le cas (et ce n'est pas le cas de ton constructeur), je préfère passer des références (constantes au besoin).
28/05/2010, 11h55
Invité

Bonjour,

Concernant l'allocation dynamique de Vecteur3D, il est vrai que ça n'a pas grand intérêt ici. Je j'ai écrit juste pour justifier l'écriture d'un delete

Par contre, les paramètre sont des pointeurs, parce que les Point3D sont des pointeurs sur des objets existants, qui ont été crées avec un new (naturellement) et ne seront normalement supprimés qu'en fin d'exécution.
Toute mon organisation est basée sur cette logique
1- class TMatricule qui contient un objet de type void et des caractéristiques telle que VISIBLE
2- les classes Point3D, TLigne et TObjet qui décrivent les objets correspondants. Chaque objet possède un matricule, un matricule peut définir plusieurs objets en fonction de l'historique des modifications
3- la classe TLigne définit une succession de pointeurs sur matricule qui correspondent à des points (liste chainée).
etc. etc.

Suite à nos échanges concernant les passages par référence, il est vrai que pour des cas comparables Borland passe les paramètres par référence. Je m'y suis attelé et j'ai modifié en conséquence. C'était assez fastidieux, il m'en reste probablement encore un peu dans d'autres .h, je les ferai, c'est promi.
Il se trouve que j'avais un long calcul dont j'avais mesuré le temps d'exécution, mais seulement avec ma trotteuse : 30s. Après modification, j'ai mesuré 28s. Donc la différence n'est pas mesurable.

Quant à l'aspect pointeur NULL, qui dit que je ne les teste pas dans mes constructeurs? Ce que j'ai écrit dans mon message n'est pas un exemple réel, mais que j'ai tapé pour montrer le principe de la méthode que j'utilisais, sans pour autant dire que c'est la meilleure, ou surtout la seule.

Cordialement.
28/05/2010, 12h53
Médinoc
Je pense qu'une bonne partie de l'implémentation des opérateurs consiste à s'assurer qu'on en viole pas les règles de base:
- Les opérateurs arithmétiques sont conçus pour marcher sur des valeurs.
- D'ailleurs, on ne peut pas les redéfinir pour deux pointeurs (mais on peut pour un pointeur et un objet).
- Les opérateurs arithmétiques ne modifient pas les objets passés en paramètre (a+b ne doit pas avoir l'effet de a+=b) et doivent donc retourner un nouvel objet
- Le nouvel objet est retourné par valeur également.
Bien sûr, on peut "tordre" un peu ces règles si l'objet en question est un pointeur intelligent vers le "vrai" objet (ce qui tend à être plus ou moins le cas pour les classes comme std::string, CString, etc.). Mais même dans ce cas, ledit pointeur intelligent est retourné par valeur.

En règle générale, si un opérateur doit retourner une référence, c'est soit une référence vers l'objet lui-même (*this), soir une référence vers un objet contenu (T& vector<T> :: operator[] (size_t index), etc.)
28/05/2010, 19h47
3DArchi

Salut,

Citation:

Envoyé par Pierre Dolez

Quant à l'aspect pointeur NULL, qui dit que je ne les teste pas dans mes constructeurs?

Ce que j'entendais ce n'est pas tester la valeur NULL du pointeur, mais que NULL est une valeur acceptable dans le contrat de la fonction. En d'autres termes, si tu passes NULL la fonction réussie et l'objet ressort avec un état valide. Ca ne peut pas être if(null) -> error.