Discussion :

[choinul]

Bonjour à tous,
J'ai un problème pour la libération d'un pointeur...

Comment je fais pour libérer un pointeur d'une fonction sachant que je le renvoie par un return...
Le code après le return va être ignoré, alors, ou puis-je mettre mon delete?

C'est peut-etre pas très clair, donc voici un petit exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
      LIST* list_inter;
      list_inter = new LIST;
 
      // traitements permettant de calculer list_inter
 
 
      return new MFDPOSS(list_inter);
    }

Comment je fais pour libérer le pointeur list_inter puisque je l'utilise dans mon return? Je crois qu'on peut le faire dans le destructeur de ma classe LIST, mais je ne suis pas sur de la manière de le faire.

Merci pour votre aide!

[JolyLoic]

- Soit tu demande à l'appelant de ta fonction d'appeler le delete au bon moment pour lui.

- Soit tu emploies des pointeurs intelligents.

[choinul]

- Soit tu demande à l'appelant de ta fonction d'appeler le delete au bon moment pour lui.

En fait, ce pointeur n'est utilisé que localement dans la fonction, je ne peux donc pas le deleter à partir de l'appelant.

- Soit tu emploies des pointeurs intelligents.

Je ne connais pas les pointeurs intelligents...

Mais si je fais dans le destructeur de ma classe LIST un "delete this;", est-ce que ça va marcher?
Je pensais qu'à la fin d'une fonction les destructeurs des éléments locaux étaient appelés... Non?

Merci encore pour vos eclaircissements...

[Aurelien.Regat-Barrel]

Ben pour que le destructeur soit appelé il faut que delete le soit...
Regarde du côté des smart ptr et du RAII:
http://c.developpez.com/faq/cpp/?pag...S_intelligents
http://c.developpez.com/faq/cpp/?pag...POINTEURS_raii

[Jean-Marc.Bourguet]

Code :

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

1
2
3
4
5
6
7
8
9
10
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
      LIST* list_inter;
      list_inter = new LIST;
 
      // traitements permettant de calculer list_inter
 
 
      return new MFDPOSS(list_inter);
    }

Si j'ai bien compris (et donc en supposant que MFDPOSS n'a pas besoin du contenu de la liste par apres) , version bete est mechante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
      LIST* list_inter;
      list_inter = new LIST;
 
      // traitements permettant de calculer list_inter
 
      MFDPOSS* result = new MFDPOSS(list_inter);
      delete list_inter;
      return result;
    }

version SL

Code :

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

1
2
3
4
5
6
7
8
9
10
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
      std::auto_ptr<LIST> list_inter;
      list_inter = new LIST;
 
      // traitements permettant de calculer list_inter
 
 
      return new MFDPOSS(list_inter.get());
    }

Version Jean-Marc

Code :

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

1
2
3
4
5
6
7
8
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
     LIST list_inter;
      // traitements permettant de calculer list_inter
 
 
      return new MFDPOSS(&list_inter);
    }

[choinul]

Merci pour votre aide!

Je pense que je vais devoir me mettre aux pointeurs intelligents...

Seulement, n'existe-t-il pas une manière de résoudre mon problème sans ces pointeurs intelligents... ?

Je ne suis pas contre, mais ça semble un peu plus complexe...

[choinul]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
      LIST* list_inter;
      list_inter = new LIST;
 
      // traitements permettant de calculer list_inter
 
      MFDPOSS* result = new MFDPOSS(list_inter);
      delete list_inter;
      return result;
    }

Oui, mais là, je ne fais que transférer le problème sur result... Comment je fais alors pour deleter result?

Code :

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

1
2
3
4
5
6
7
8
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
     LIST list_inter;
      // traitements permettant de calculer list_inter
 
 
      return new MFDPOSS(&list_inter);
    }

Oui, mais je perd les avantages des pointeurs...

Je vais peut-etre me mettre aux pointeurs intelligents, alors!
Pourquoi tout le monde conseille les pointeurs intelligents "boost" mais que dans les exemples, ce sont les pointeurs intelligents "std::auto_ptr" qui sont le plus souvent utilisé?

Merci encore pour vos réponses!

[Aurelien.Regat-Barrel]

L'avantage c'est que tu es garanti de sa libération, même en cas d'exception avant d'atteindre le return.

http://c.developpez.com/faq/cpp/?pag...NTEURS_autoptr

[choinul]

Il vaut peut-etre mieux que j'utilise les pointeurs intelligents boost, alors?

http://c.developpez.com/faq/cpp/?pag...oost_smart_ptr

[choinul]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
MFDPOSS* intersectionMF(MFDPOSS *tmpdposs)
    {
      std::auto_ptr<LIST> list_inter;
      list_inter = new LIST;
 
      // traitements permettant de calculer list_inter
 
 
      return new MFDPOSS(list_inter.get());
    }

on fait un list_inter.get() sur un pointeur, c'est la syntaxe? le .get, c'est nécessaire parcequ'on utilise des pointeurs intelligents? C'est embetant si la syntaxe change pour les pointeurs intelligents...

Dernière question : l'utilisation conjointe de pointeurs "normaux" et de pointeurs intelligents ne pose elle pas de problèmes?

(Je commence à regarder la doc des pointeurs intelligents...)