Discussion :

[Neckara]

Bonjour,

Imaginons que je possède le code suivant :

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
#include <iostream>
 
class Foo{
     public : 
          Foo(void){ throw int(0); }
 
}
 
int main(void)
{
      Foo * ptr = nullptr;
      try {
            ptr = new Foo;
     } catch (int)
     {
            std::cout << ptr << std::endl;
     }
}

new va allouer l'espace mémoire puis il va l'initialisé en appelant le constructeur de Foo.
Mais ce dernier va lancer une exception, je vais donc entrer dans le catch, ptr valant toujours nullptr.

Il me semblerait logique que new ai lui-même désalloué l'espace qu'il a alloué sinon on risquerait d'avoir des fuites de mémoires.
Mais que dit exactement la norme à ce sujet ?

Si j'utilise ensuite un new [], et qu'un seul des constructeur échoue, ce serait dommage qu'il désalloue tout l'espace mémoire et qu'il détruise les objets déjà construits.
Mais d'un autre côté, comme on a une exception, on ne peux pas récupérer de pointeurs et on se retrouverait dans le cas précédant avec une fuite mémoire.

Je vois ce que le compilateur doit faire, mais j'aimerais savoir ce qu'en pense la norme.

[Invité]

Si une exception est lancée, ton programme s'arrête (enfin moi s'est le cas) donc obligation de libérer toute la mémoire, sinon, tu auras des fuites de mémoire.

new [] instancie juste un tableau, mais en aucun cas les éléments de ton tableau, si tu veux tester si un élément de ton tableau à bien été alloué, tu dois faire le test un par un pour chaque élément de ton tableau.

Tu peux toujours, si tu souhaite que le tableau soit libéré dans n'importe quel cas, utiliser quelque chose comme ceci :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
 
int main(void)
{
      std::unique_ptr<Foo[taille]> ptr;
     try {
           ptr = std::make_unique<Foo[taille]>();
     } catch (int)
     {
            std::cout << ptr << std::endl;
     }
}

Si j'ai bien compris la norme.

[Neckara]

Si une exception est lancée, ton programme s'arrête (enfin moi s'est le cas)

Heu... non vu que je fais un catch...

new [] instancie juste un tableau, mais en aucun cas les éléments de ton tableau

new[] appelle le constructeur par défaut pour chaque élément du tableau.

si tu veux tester si un élément de ton tableau à bien été alloué, tu dois faire le test un par un pour chaque élément de ton tableau.

new[] alloue un seul bloc contiguë en mémoire, l'allocation se fait en une seule fois et échoue ou réussie.
Soit tout le tableau est alloué, soit il ne l'est pas.

Tu peux toujours, si tu souhaite que le tableau soit libéré dans n'importe quel cas, utiliser quelque chose comme ceci :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
 
int main(void)
{
      std::unique_ptr<Foo[taille]> ptr;
     try {
           ptr = std::make_unique<Foo[taille]>();
     } catch (int)
     {
            std::cout << ptr << std::endl;
     }
}

Totalement HS ici.

[Ehonn]

Pour moi la question ne se pose pas vraiment, si new échoue, ptr n'est pas modifié donc, tu ne peux pas faire de delete toi-même dessus.

Sinon, voici une piste sur Can I throw an exception from a constructor? From a destructor? :

You should throw an exception from a constructor whenever you cannot properly initialize (construct) an object. There is no really satisfactory alternative to exiting a constructor by a throw.

[Neckara]

Pour moi la question ne se pose pas vraiment, si new échoue, ptr n'est pas modifié donc, tu ne peux pas faire de delete toi-même dessus.

Oui, c'est ce que j'ai dit dans mon premier post.

Je veux juste savoir ce que dit la norme à ce sujet.

Sinon, voici une piste sur Can I throw an exception from a constructor? From a destructor? :

?
Je ne comprend pas pourquoi tu me montre ce lien.

[Blainey]

Oui, new[] va tout supprimer

Une solution est de faire un allocation sans appel de constructeur (par exemple avec malloc) puis de faire un placement new pour appeler le constructeur sur chaque élément. Regarde les sources de vector, je crois qu'il fait comme ça. Par contre, c'est une technique bas niveau et peu sécurisée, à encapsuler dans un classe RAII

[Neckara]

Oui, new[] va tout supprimer

Une solution est de faire un allocation sans appel de constructeur (par exemple avec malloc) puis de faire un placement new pour appeler le constructeur sur chaque élément. Regarde les sources de vector, je crois qu'il fait comme ça. Par contre, c'est une technique bas niveau et peu sécurisée, à encapsuler dans un classe RAII

Donc ensuite pour libérer, j'appelle explicitement le constructeur puis je libère avec free() ?

Code :

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

1
2
3
4
5
6
7
Foo * myTab = malloc(...);
for(...)
      new(myTab + i) Foo;
//...
for(...)
      myTab[i].~Foo();
free(myTab);

Très intéressante comme idée. .

Je vais essayer de mon plonger dans la norme pour la première partie de ma question .