Perché Alexandrescu non può utilizzare std :: uncaught_exception() per implementare SCOPE_FAIL in ScopeGuard11?

Question

Molte persone sono senza dubbio familiarità con il modello Mr. Alexandrescus ScopeGuard (ora parte di Loki) e la nuova versione ScopeGuard11 qui presentata: http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Andrei-Alexandrescu-Systematic-Error-Handling-in-C

con fonte qui: https://gist.github.com/KindDragon/4650442

Nel suo discorso in C++ e oltre il 2012 ha menzionato che non è stato in grado di trovare un modo per rilevare correttamente se l'oscillazione è stata interrotta a causa di un'eccezione. Pertanto non è stato in grado di implementare una macro SCOPE_FAIL che eseguisse il lambda fornito (di solito utilizzato per il codice di rollback) se e solo se l'ambito è stato chiuso a causa di un'eccezione. Ciò renderebbe non necessaria la funzione membro dismiss() e renderebbe il codice più leggibile.

Dato che io sono in alcun modo come genio o vissuta come Mr. Alexandrescu mi aspetto che implementando SCOPE_FAIL non è così facile come questo:

~ScopeGuard11(){      //destructor 
    if(std::uncaught_exception()){ //if we are exiting because of an exception 
     f_();       //execute the functor 
    } 
    //otherwise do nothing 
} 

mia domanda è perché no?

Answer 1

Con una classe ScopeGuard11 con il distruttore, è possibile chiamare il membro f_, anche se non è l'ambito corrente (che dovrebbe essere protetto dalla guardia) che viene chiuso a causa di un'eccezione. L'uso di questa protezione non è sicuro nel codice che potrebbe essere utilizzato durante la pulizia delle eccezioni.

Prova questo esempio:

#include <exception> 
#include <iostream> 
#include <string> 

// simplified ScopeGuard11 
template <class Fun> 
struct ScopeGuard11 { 
    Fun f_; 
    ScopeGuard11(Fun f) : f_(f) {} 
    ~ScopeGuard11(){      //destructor 
     if(std::uncaught_exception()){ //if we are exiting because of an exception 
      f_();       //execute the functor 
     } 
     //otherwise do nothing 
     } 
}; 

void rollback() { 
    std::cout << "Rolling back everything\n"; 
} 
void could_throw(bool doit) { 
    if (doit) throw std::string("Too bad"); 
} 

void foo() { 
    ScopeGuard11<void (*)()> rollback_on_exception(rollback); 
    could_throw(false); 
    // should never see a rollback here 
    // as could throw won't throw with this argument 
    // in reality there might sometimes be exceptions 
    // but here we care about the case where there is none 
} 

struct Bar { 
    ~Bar() { 
     // to cleanup is to foo 
     // and never throw from d'tor 
     try { foo(); } catch (...) {} 
    } 
}; 

void baz() { 
    Bar bar; 
    ScopeGuard11<void (*)()> more_rollback_on_exception(rollback); 
    could_throw(true); 
} 

int main() try { 
    baz(); 
} catch (std::string & e) { 
    std::cout << "caught: " << e << std::endl; 
} 

Che ci si vuole vedere uno rollback al momento di lasciare baz, ma vedrete due - tra cui uno spurio di lasciare foo.