Come dovrebbe essere liberata la memoria dopo che un'eccezione è stata lanciata in C++?

Question

Mi scuso se questa domanda è un duplicato - ho cercato per un po ', ma è possibile che il mio Google-fu non sia all'altezza.

Sto modificando un programma C++ che chiama in una libreria C. La libreria C assegna un po 'di memoria (usando malloc()), e il programma C++ lo usa e poi lo libera. Il problema è che il programma C++ può lanciare un'eccezione a metà dell'esecuzione, facendo in modo che la memoria allocata non venga mai liberata.

Come un (piuttosto artificiosa) Esempio:

/* old_library.c */ 
char *allocate_lots() { 
    char *mem = (char *)malloc(1024); 
    return mem; 
} 

/* my_prog.cpp */ 
void my_class::my_func() { 
    char *mem = allocate_lots(); 
    bool problem = use(mem); 
    if (problem) 
     throw my_exception("Oh noes! This will be caught higher up"); 
    free(mem); // Never gets called if problem is true 
} 

La mia domanda è: come debbo fare con questo? La mia prima idea era quella di avvolgere il tutto in un blocco try/catch, e nel catch basta controllare e liberare la memoria e ri-lanciare l'eccezione, ma questo mi sembra sgraziato e goffo (e non funzionerebbe bene se io voglio effettivamente catturare un'eccezione). C'è un modo migliore per farlo?

EDIT: Probabilmente avrei dovuto dire che stiamo usando g ++ 4.2.2, dal 2007, prima che fosse introdotto std :: unique_ptr. Chalk fino all'inerzia aziendale.

Answer 1

Usa std::unique_ptr con una delezione personalizzato che chiama gratis:

class free_mem { 
public: 
    void operator()(char *mem) { free(mem); } 
}; 

void my_class::my_func() { 
    std::unique_ptr<char, free_mem> mem = allocate_lots(); 

Answer 2

È necessario assicurarsi che non si butta solo dopo aver liberato la memoria - o che utilizzare una idonea struttura puntatore intelligente per memorizzare il mem, in modo tale che quando il throw accade, e lo stack snoda, il mem viene liberato.

Answer 3

C'è qualche motivo per non liberare semplicemente la memoria all'interno della clausola if?

if (problem) { 
    free (mem); 
    throw my_exception ("Drat!"); 
} 

Answer 4

Wrap quel briccone:

struct malloc_deleter { 
    template <typename T> 
    void operator() (T* p) const { 
    free(p); 
    } 
}; 

void my_class::my_func() { 
    std::unique_ptr<char[],malloc_deleter> mem{allocate_lots()}; 
    bool problem = use(mem.get()); 
    if (problem) 
     throw my_exception("Oh noes! This will be caught higher up"); 
} 

Answer 5

Uso unique_ptr: http://coliru.stacked-crooked.com/view?id=cd3f0fc64d99cc07a2350e2ff9686500-542192d2d8aca3c820c7acc656fa0c68

#include <stdexcept> 
#include <iostream> 

#include <memory> 

/* old_library.c */ 
char *allocate_lots() 
{ 
    return static_cast<char*>(malloc(1024)); 
} 

struct my_exception : virtual std::exception { 
    const char* const msg; 
    my_exception(const char* const msg) : msg(msg) {} 
    const char* what() const noexcept { return msg; } 
}; 

struct my_class 
{ 
    struct Free { void operator() (char* p) const { free(p); } }; 
    /* my_prog.cpp */ 
    void my_func() 
    { 
     std::unique_ptr<char, Free> mem; 

     mem.reset(allocate_lots()); 
     bool problem = use(mem.get()); 

     if(problem) 
     { 
      throw my_exception("Oh noes! This will be caught higher up"); 
     } 
    } 

    static bool use(char*) { return true; } 
}; 

int main() 
{ 
    my_class prog; 
    prog.my_func(); 
} 

Answer 6

Dal y ou're usando una vecchia versione del compilatore che non ha unique_ptr, è possibile scrivere il RAII involucro voi stessi:

class ResourceWrapper { 
public: 
    ResourceWrapper(char* ptr) : m_ptr(ptr) {} 
    ~ResourceWrapper() { free(m_ptr); } 
    // whatever getters suit you, at the very least: 
    char* get() const { return m_ptr; } 
private: 
    char* const m_ptr; 
}; 

void my_class::my_func() { 
    ResourceWrapper mem(allocate_lots()); 
    bool problem = use(mem.get()); 
    if (problem) 
     throw my_exception("Oh noes! This will be caught higher up"); 
} 

Basta fare attenzione a non per consentire copia/assegnazione, anche in modo implicito (che è il motivo per cui ho fatto m_ptr const) o rischi di finire con la doppia liberazione della memoria (la semantica "sposta" alla auto_ptr è meglio evitare a meno che non sia necessario il ).

Answer 7

Poiché non è possibile utilizzare std::unique_ptr, è possibile creare la propria classe deleter che controllerebbe la durata del puntatore in modo RAII. Per semplificare questo esempio non avvolge il puntatore reale ma esiste al suo fianco; un approccio più sicuro sarebbe quello di creare una vera classe di puntatore intelligente.

class AutoFree 
{ 
public: 
    AutoFree(void* p) : m_p(p) 
    { 
    } 
    ~AutoFree() 
    { 
     free(m_p); 
    } 
private: 
    void* m_p; 
}; 

void my_class::my_func() { 
    char *mem = allocate_lots(); 
    AutoFree mem_free(mem); 
    bool problem = use(mem); 
    if (problem) 
     throw my_exception("Oh noes! This will be caught higher up"); 
}