new anonyme et fuite mémoire

[Darz4]

Bonjour,

J'ai cherché un peu partout, mais n'ai pas trouvé de réponse à la question suivante.
Lors de cet appel :

Code :

MaProcedure( new long( 1 ) );

Sachant que MaProcedure ne fait pas de delete sur son paramètre, ce code produit-il une fuite mémoire ?
Ou bien l'appel à delete est-il implicite à la suite de cet appel ? Sachant que l'on instancie un type de base et non une classe.

Cordialement

[Awakening]

Oui, cela génère une fuite mémoire, la variable ne sera pas détruite.
La destruction d'une variable à l'aide de new doit se faire explicitement avec un delete.

Le principe de l'allocation dynamique est justement de devoir manager "manuellement" une variable (qu'elle contienne un type de base ou non).

Pourquoi faire une telle chose, et ne pas passer par une fonction avec un passage de paramètre par référence ?

[Darz4]

Je vais donc déclarer une variable "dummy" et passer son adresse à la fonction. C'est moche, mais je n'ai pas le choix car il m'est interdit de modifier ou surcharger MaProcedure.

Merci pour votre réponse.

[Iradrille]

Envoyé par Awakening

Pourquoi faire une telle chose, et ne pas passer par une fonction avec un passage de paramètre par référence ?

Passer par un pointeur au lieu d'une référence est une question de préférence.
Perso je préfère un pointeur à la place d'une référence, je trouve ça plus lisible de passer un pointeur quand je sais que le paramètre va être modifié.
Par contre les références constantes sont pratique pour le passage d'objet.

Envoyé par Darz4

C'est moche, mais je n'ai pas le choix car il m'est interdit de modifier ou surcharger MaProcedure.

Si vraiment le passage de pointeur te dérange, tu peux déclarer une autre fonction qui appellera MaProcedure.

Code :

void foo(long& l) { MaProcedure(&l); }

[gbdivers]

Quelques petites corrections...

Le principe de l'allocation dynamique est justement de devoir manager "manuellement" une variable (qu'elle contienne un type de base ou non).

Non, l'allocation dynamique répond surtout à d'autres besoins (utilisation du tas plutôt que la pile, polymorphisme d'héritage). La gestion manuelle n'est qu'une contrainte technique du fait que les anciennes versions du C++ ne proposait pas de pointeurs intelligents et que les personnes ne voulait pas utiliser TR1, boost ou créer leurs propres pointeurs intelligents.
Plus d'excuse maintenant

Je vais donc déclarer une variable "dummy" et passer son adresse à la fonction. C'est moche, mais je n'ai pas le choix car il m'est interdit de modifier ou surcharger MaProcedure.

En quoi c'est moche parce que tu crées un objet pour rien. Pourquoi MaProcedure a besoin de lui fournir une objet qui n'est pas utilisé en dehors de MaProcedure ?
C'est peut être un problème de conception de MaProcedure si cela a un sens de pouvoir l'appeler sans avoir besoin de créer un objet. Si c'est pas le cas, c'est un choix volontaire (ou non) du créateur de MaProcedure d'obliger à créer une variable temporaire, plaint toi à lui

Il faut écrire :

Code :

1
2
3
4
5
6
7
// avec variable sur la pile
long l = 1234L;
MaProcedure(&l);
 
// avec pointeur intelligent
unique_ptr<long> p (new long(1234L));
MaProcedure(p.get());

Passer par un pointeur au lieu d'une référence est une question de préférence.

Petit bémol, le pointeur donne une petite garantie en moins par rapport à une référence, elle peut être nulle et il est donc impératif de tester avant utilisation :

Code :

1
2
3
4
5
6
7
8
9
voif foo(int * p) {
    if (i) { // obligatoire !!! (là ou a distance...)
        *p = 10; // on utilise p
    }
}
 
void bar(int & r) {
    r = 10; // on utilise r directement
}

Si vraiment le passage de pointeur te dérange, tu peux déclarer une autre fonction qui appellera MaProcedure.

Code :

void foo(long& l) { MaProcedure(&l); }

C'est probablement le mieux d'ajouter une indirection pour ne pas avoir à écrire le code pour créer une variable temporaire systématiquement. Par contre, le code oblige à créer une variable temporaire :

Code :

1
2
3
4
5
6
7
8
9
void foo(long& l) { MaProcedure(&l); }
 
long l = 1234L;
 
// appel directe de MaProcedure
MaProcedure(&l);
 
// en passant par foo
MaProcedure(l);

Tu économises simplement le &

Vaut mieux écrire :

Code :

1
2
void foo(long l) { MaProcedure(&l); }
foo(1234L);