Cómo detectar el desenrollado de la pila en un Destructor

Question

Tengo un objeto C++ simple que creo al comienzo de la función F() para asegurar que se invocan dos funciones coincidentes (OpDo, OpUndo) al inicio y el retorno de la F() , utilizando el constructor y el destructor del objeto. Sin embargo, no quiero que la operación se deshaga en caso de que se haya lanzado una excepción dentro del cuerpo de F(). ¿Es esto posible hacerlo limpiamente? He leído sobre std :: uncaught-exception, pero su uso no parece ser recomendable.

Answer 1

La mayoría de las personas han usado std::uncaught_exception() para tratar de saber si hay una excepción pendiente, por lo que pueden lanzar una excepción desde un destructor si no hay uno ya. Eso generalmente se considera No una Buena Idea.

Si no desea deshacer una operación si se ha lanzado una excepción, debería funcionar.

Recuerde que el destructor es su última oportunidad de liberar los recursos que tiene un objeto, porque una vez que el destructor finaliza, el objeto no existe y todos los recursos que posee se filtran de forma permanente. Si OpDo() asigna cualquier memoria o manejadores de archivos o lo que sea, debe tratar eso en el destructor pase lo que pase.

Answer 2

Vamos a suponer que su F vuelve alguna clase auxiliar:

Helper F() 
{ 
    MyClass doUndoWrapper; 
} 

Cuando el flujo es normal - se crea ayudante. Cuando se produce una excepción, no se crea una copia de Helper. Intenta usar esta semántica al ubicar al constructor de la región privada de Helper y declarar a F como amigo, para que nadie pueda crear ayuda.

class Helper 
{ 
private: 
    friend Helper F(); 
    Helper(){ //place there OpDo semantic - first entry 
       // construct this class 
    Helper(const Helper& copy){ //this must present to allow stack operations 
       // copy constructor will be called at end of `F` to return value 
       // so place OpUndo semantic there to mark success without exception 

Answer 3

Puede subvertir el Scope Guard idiom. En lugar de no hacer algo en el destructor cuando se produce ninguna excepción, invertimos eso y única hacer algo si se lanza una excepción:

class DoUndoRAII{ 
public: 
    DoUndoRAII() 
    : noexcept_(false) 
    { 
    // your stuff here 
    } 

    ~DoUndoRAII(){ 
    if(noexcept_){ 
     // do whatever you need to do 
    } 
    } 

    void no_exception(){ 
    noexcept_ = true; 
    } 

private: 
    bool noexcept_; 
}; 

void func(){ 
    DoUndoRAII do_undo; 

    // last line 
    do_undo.no_exception(); 
} 

Cuando se produce una excepción, do_undo.no_exception() nunca serán llamados y por lo tanto, nunca establezca el valor noexcept_ en verdadero. :) Se puede encontrar un ejemplo here on Ideone.