Qu’advient-il de la mémoire allouée par `new` si le constructeur lance?

Ce code provoquera-t-il une fuite de mémoire?

#include  class MyClass { public: MyClass() { throw std::runtime_error("Test"); } }; int main() { try { MyClass * myClass = new MyClass; } catch (const std::exception & exc) { // Memory leak? } return 0; } 

La mémoire allouée par new n’est jamais effacée. Est-ce pris en charge en interne ou s’agit-il d’une fuite de mémoire?

La mémoire sera automatiquement libérée avant la propagation de l’exception.

Ceci est essentiel car a) le programme ne reçoit jamais de pointeur à libérer et b) même s’il le faisait, il ne disposerait d’aucun moyen portable pour le libérer puisque la mémoire n’est jamais devenue un object que vous pouvez supprimer.

La mémoire sera correctement désallouée.

Questions connexes à SO.

  • Est-il jamais dangereux de lancer une exception dans un constructeur?
  • C ++: gérer les ressources si les constructeurs peuvent générer des exceptions (Référence à la FAQ 17.4)
  •  prasoon@prasoon-desktop ~ $ cat noleak.cpp && g++ noleak.cpp && valgrind --leak-check=full ./a.out #include  class MyClass { public: MyClass() { throw std::runtime_error("Test"); } }; int main() { try { MyClass * myClass = new MyClass; } catch (const std::exception & exc) { // Memory leak? } return 0; } ==3652== Memcheck, a memory error detector ==3652== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==3652== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info ==3652== Command: ./a.out ==3652== ==3652== ==3652== HEAP SUMMARY: ==3652== in use at exit: 0 bytes in 0 blocks ==3652== total heap usage: 3 allocs, 3 frees, 106 bytes allocated ==3652== ==3652== All heap blocks were freed -- no leaks are possible ==3652== ==3652== For counts of detected and suppressed errors, rerun with: -v ==3652== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 17 from 6) prasoon@prasoon-desktop ~ $ 

    15,2 / 2 $ – “Un object partiellement construit ou partiellement détruit aura des destructeurs exécutés pour toutes ses classes de base entièrement construites et ses membres non-variants, c’est-à-dire pour les sous-objects pour lesquels le constructeur principal (12.6.2) a terminé l’exécution De même, si le constructeur non-délégué d’un object a terminé son exécution et qu’un constructeur-délégué de cet object quitte avec une exception, le destructeur de l’object est appelé. Si l’object a été alloué dans une nouvelle -expression, la fonction de désallocation correspondante (3.7.4.2, 5.3.4, 12.5), le cas échéant, est appelée pour libérer le stockage occupé par l’object.