Discussion :

[killwin]

Bonjour, je reviens avec un vieux problème.

J'ai une fonction qui crée des objets pour les placer dans un vecteur. Comme tout le monde sait, lorsqu'une fonction se termine elle libère tout ce qui a été déclaré, instancié ainsi que les pointeurs (directs).

J'aimerais écrire donc ceci de façon moins compliquée et avec un style c++ :

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
private :
vector<CDraw*> images;
 
...
 
void fonction() {
 
CDraw **draw;
draw = (CDraw**)malloc(sizeof(CDraw*));
*draw = new CDraw(true, complet_file.c_str(), coord_, coef_resol);
 
// We reverse picture on Y axis
if(orientation_)
(*draw)->reverse_H_SDL();
 
images.push_back(*draw);
 
}

[superZozo]

salut !

c'est le bazard ton truc ?!

Comme tout le monde sait, lorsqu'une fonction se termine elle libère tout ce qui a été déclaré, instancié ainsi que les pointeurs (directs).

c'est quoi un pointeur direct. Si tu instancie avec new il faut libérer avec delete dans ta fonction ou ailleurs (destructeur, autre fonction...).

je ne comprends pas trop l'intéret du double pointeur ni du malloc...

enfin si tu fait du c++, tu fait du c++, pas du C style c++

[killwin]

Justement, si je fais au milieu de la fonction un

Code :

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

1
2
3
void fonction() {
   int * p1 = new int;
}

Lorsque la fonction prendra fin, le pointeur p1 disparaîtra. J'aurais des problèmes de référencement delete ou pas delete.

L'intéret du double pointeur en C, c'est de permettre de conserver une allocation dynamique faite dans une fonction.

PS (la fin de'une fonction ne libère pas tout l'objet en mémoire me suis mal exprimé plus haut)

[superZozo]

si tuveux récupérer ton pointeur immediatement, tu peux faire

Code :

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

1
2
3
4
5
 
obj* fonction() {
obj* p1 = new obj; 
return p1;
}

sinon c'est le dernier élément de ton vector, si tu a fait ton push_back.

Classiquement, tu libère le contenu de ce vector avec le destructeur de ta classe. Il y a différentes méthodes +/- sophistiquées/élégantes/...

new est une allocation dynamique.

[Bousk]

Justement, si je fais au milieu de la fonction un

void fonction() {
int * p1 = new int;
}

Lorsque la fonction prendra fin, le pointeur p1 disparaîtra. J'aurais des problèmes de référencement delete ou pas delete.

L'intéret du double pointeur en C, c'est de permettre de conserver une allocation dynamique faite dans une fonction.

PS (la fin de'une fonction ne libère pas tout l'objet en mémoire me suis mal exprimé plus haut)

Bonjour,

il faudrait (re)voir un cours sur les pointeurs.
Oui p1 sera supprimée, mais scoop : on s'en moque.
La zone mémoire allouée et sur laquelle pointe p1 subsiste jusqu'à son delete.

Tu n'as aucun intérêt à allouer un pointeur de pointeur, à part se faire un noeud au cerveau et créer une possible fuite mémoire supplémentaire.
Et d'ailleurs, ton code en présente une belle de fuite mémoire.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void fonction() {
 
CDraw *draw = new CDraw(true, complet_file.c_str(), coord_, coef_resol);
 
// We reverse picture on Y axis
if(orientation_)
draw->reverse_H_SDL();
 
images.push_back(draw);
 
}

[camboui]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
vector< shared_ptr<CDraw> > images;
 
...
 
void fonction()
{
shared_ptr<CDraw> draw = shared_ptr<CDraw>::make(true, complet_file.c_str(), coord_, coef_resol);
 
// We reverse picture on Y axis
if(orientation_)
 draw->reverse_H_SDL();
 
images.push_back(draw);
}

C'est tout je crois.

[gbdivers]

Code :

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

shared_ptr<CDraw>::make(...) -> make_shared<CDraw>(...)

Ou unique_ptr si on veut que le tableau soit l'unique responsable de la durée de vie des objets pointés (ie tous les objets sont dans le tableau et si le tableau est détruit, aucun objet n'est censé encore être utilisé)

Mais sinon, c'est effectivement l'approche la plus sur (pas de pointeurs nus) donc celle qui faut recommander pour les débutants et les personnes plus expérimentés (en première approche ; si ensuite, une personne plus expérimentée sait ce qu'elle fait et qu'elle a fait des tests de performances et vu que les smart pointeurs sont un frein, elle pourra changer dans un second temps)

[killwin]

Merci, je vais tester shared_ptr qui est la réponse à ma question et que je ne connaissais pas.

[piemur2000]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void fonction() {
 
CDraw *draw = new CDraw(true, complet_file.c_str(), coord_, coef_resol);
 
// We reverse picture on Y axis
if(orientation_)
draw->reverse_H_SDL();
 
images.push_back(draw);
 
}

Il faut noter que ce code contient aussi une fuite mémoire si la fonction reverse_H_SDL peut lancer une exception. Dans ce cas il convient de faire:

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
void fonction() {
 
    CDraw *draw = new CDraw(true, complet_file.c_str(), coord_, coef_resol);
 
    // We reverse picture on Y axis
    try{
        if(orientation_)
            draw->reverse_H_SDL();
    }
    catch (...) {      // Catch all exceptions.
        delete draw;   // Delete the draw object.
        throw;         // Rethrow the exception so it can be handled outside the function.
    }
 
    images.push_back(draw);
 
}

et bien sur il faut détruire les objets créés dans le destructeur:

Code :

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

1
2
3
4
5
~ClassName() {
    for (std::vector<CDraw*>::iterator it = images.begin(); it != images.end(); ++it) {
        delete *it;
    }
}

Tout cela est bien sur beaucoup moins lisible et safe que l'utilisation de shared_ptr (ou unique_ptr).

[3DArchi]

Salut,

Merci, je vais tester shared_ptr qui est la réponse à ma question et que je ne connaissais pas.

Un peu de lecture très utile en ce cas : Présentation des pointeurs intelligents en C++ par Loïc Joly

[killwin]

C'est résolu et merci pour la doc sur les pointeurs intelligents.