diritti d'uso di std :: uncaught_exception in un distruttore

Question

Ci sono alcuni articoli che concludono "mai un'eccezione da un distruttore", e "std :: uncaught_exception() non è utile", per esempio:

• http://www.gotw.ca/gotw/047.htm (scritto da Herb Sutter)

Ma a quanto pare non ho capito il punto. Così ho scritto un piccolo esempio di test (vedi sotto).

Dato che tutto va bene con l'esempio di test, apprezzerei molto i commenti su cosa potrebbe esserci di sbagliato in questo?

risultati della prova:

./main

 
    Foo::~Foo(): caught exception - but have pending exception - ignoring 
    int main(int, char**): caught exception: from int Foo::bar(int) 

./main 1

 
    Foo::~Foo(): caught exception - but *no* exception is pending - rethrowing 
    int main(int, char**): caught exception: from Foo::~Foo() 

esempio:

// file main.cpp 
// build with e.g. "make main" 
// tested successfully on Ubuntu-Karmic with g++ v4.4.1 
#include <iostream> 

class Foo { 
    public: 

    int bar(int i) { 
    if (0 == i) 
     throw(std::string("from ") + __PRETTY_FUNCTION__); 
    else 
     return i+1; 
    } 

    ~Foo() { 
    bool exc_pending=std::uncaught_exception(); 
    try { 
     bar(0); 
    } catch (const std::string &e) { 
     // ensure that no new exception has been created in the meantime 
     if (std::uncaught_exception()) exc_pending = true; 

     if (exc_pending) { 
     std::cerr << __PRETTY_FUNCTION__ 
        << ": caught exception - but have pending exception - ignoring" 
        << std::endl; 
     } else { 
     std::cerr << __PRETTY_FUNCTION__ 
        << ": caught exception - but *no* exception is pending - rethrowing" 
        << std::endl; 
     throw(std::string("from ") + __PRETTY_FUNCTION__); 
     } 
    } 
    } 

}; 

int main(int argc, char** argv) { 
    try { 
    Foo f; 
    // will throw an exception in Foo::bar() if no arguments given. Otherwise 
    // an exception from Foo::~Foo() is thrown. 
    f.bar(argc-1); 
    } catch (const std::string &e) { 
    std::cerr << __PRETTY_FUNCTION__ << ": caught exception: " << e << std::endl; 
    } 
    return 0; 
} 

AGGIUNTI : In altre parole: nonostante gli avvertimenti in alcuni articoli funziona come previsto, quindi cosa potrebbe esserci di sbagliato?

Answer 1

Non c'è niente di tecnicamente sbagliato nel codice. È perfettamente sicuro in quanto non terminerai mai accidentalmente perché hai lanciato un'eccezione quando non era sicuro. Il problema è che non è utile, in quanto occasionalmente non genera nemmeno un'eccezione quando è sicuro. La documentazione del tuo distruttore dice fondamentalmente "questo potrebbe o non potrebbe generare un'eccezione".

Se occasionalmente non si genera un'eccezione, si potrebbe anche non generare mai un'eccezione. In questo modo, sei almeno coerente.

Answer 2

Herb Sutter fa riferimento a un altro problema. Sta parlando di:

try 
{ 
} 
catch (...) 
{ 
    try 
    { 
     // here, std::uncaught_exception() will return true 
     // but it is still safe to throw an exception because 
     // we have opened a new try block 
    } 
    catch (...) 
    { 
    } 
} 

Quindi il problema è che se std::uncaught_exception() restituisce vero non si sa con certezza se si può buttare tranquillamente un'eccezione oppure no. Si finisce per evitare di lanciare un'eccezione quando std::uncaught_exception() restituisce true solo per sicurezza.