Fugas de C++ en caso de excepción incluso mediante el uso de punteros inteligentes

Question

Soy nuevo en el mundo de los punteros inteligentes. He hecho mi lectura y todos declararon que los punteros inteligentes evitarán la pérdida de memoria incluso cuando el programa salga después de encontrar una excepción.

Escribí un programa simple para probar esto, pero Valgrind me dice que mi programa está perdiendo memoria (tres allocs y solo uno libre).

Este es el código fuente:

#include <iostream> 
#include <memory> 

using namespace std; 

int main() 
{ 
    auto_ptr<int> ptr_int(new int(5)); 

    throw std::bad_alloc(); 

    cout << *ptr_int; 
} 

Y este informe Valgrind:

==27862== Memcheck, a memory error detector 
==27862== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al. 
==27862== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info 
==27862== Command: ./smart_pointers 
==27862== Parent PID: 5388 
==27862== 
==27862== 
==27862== HEAP SUMMARY: 
==27862==  in use at exit: 104 bytes in 2 blocks 
==27862== total heap usage: 3 allocs, 1 frees, 120 bytes allocated 
==27862== 
==27862== 4 bytes in 1 blocks are still reachable in loss record 1 of 2 
==27862== at 0x4026351: operator new(unsigned int) (vg_replace_malloc.c:255) 
==27862== by 0x804878A: main (smart_pointers.cpp:8) 
==27862== 
==27862== 100 bytes in 1 blocks are possibly lost in loss record 2 of 2 
==27862== at 0x4025BD3: malloc (vg_replace_malloc.c:236) 
==27862== by 0x40E861A: __cxa_allocate_exception (in /usr/lib/libstdc++.so.6.0.14) 
==27862== by 0x80487AE: main (smart_pointers.cpp:10) 
==27862== 
==27862== LEAK SUMMARY: 
==27862== definitely lost: 0 bytes in 0 blocks 
==27862== indirectly lost: 0 bytes in 0 blocks 
==27862==  possibly lost: 100 bytes in 1 blocks 
==27862== still reachable: 4 bytes in 1 blocks 
==27862==   suppressed: 0 bytes in 0 blocks 
==27862== 
==27862== For counts of detected and suppressed errors, rerun with: -v 
==27862== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 19 from 8) 

¿El uso de punteros inteligentes garantizan los recursos asignados serán destruidas incluso si una excepción aparezca?

Answer 1

Cuando se llama std::terminate() (como es el caso de una excepción no detectada), la limpieza normal no se ejecuta (al menos para la pila marco de main()), y como tal, la memoria que ha asignado en esa pila filtraciones de marco, a pesar de que supuestamente es administrado por un puntero inteligente. Cuando atrapa el std::bad_alloc en main() y regresa normalmente, el puntero inteligente lo hará.

Answer 2

Si no se maneja una excepción, se define su implementación si la pila se desenrollará antes de llamar al std::terminate.

Si maneja la excepción, el puntero inteligente funcionará como se espera.

Referencia:

C++ 11 15.5.1 El std::terminate() función

1 En un manejo situaciones excepción debe ser abandonada para las técnicas de manejo de errores menos sutiles. Estas situaciones son:

........

- cuando el mecanismo de manejo de excepciones no puede encontrar un controlador para una excepción lanzada, o

........

2 En tales casos se llama std::terminate(). En la situación en la que no se encuentra ningún controlador coincidente, está definido por la implementación si la pila se desenrolla o no antes de que std::terminate() se llame.

Answer 3

Si no se detecta la excepción, el desenrollado de la pila es específico de la implementación. Por lo tanto, en su caso, no libera la memoria.

Además, auto_ptr ya no se recomienda.

uso std :: unique_ptr:

unique_ptr<int> ptr_int(new int(5));