Discussion :

[ellosap]

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 :

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

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

[myzu69]

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 :

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

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

[koala01]

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

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

Code :

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

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 )

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 :

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

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 :

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

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

[Fabllot]

Bonjour,

Philosophiquement parlant:

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:

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.

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

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 :

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

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

Finish:

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

ça c'est pas un argument !

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

[Fabllot]

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

[Invité]

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

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