Gibt es einen Trick, ob ein Objekt während der Ausführung eines anderen Destruktors erstellt wird?

Question

Dies ist eine Art von Follow-up auf Why can't Alexandrescu use std::uncaught_exception() to implement SCOPE_FAIL in ScopeGuard11?

Ich möchte jemanden erkennen, ob sich MyClass im Destruktor einer anderen Klasse (oder mit einem aktiven destructor irgendwo in den Call-Stack) zu schaffen.

class MyClass 
{ 
public: 
    MyClass(){ 
     assert(???what to put here????); 
    } 
} 

void f(){ 
    MyClass m; //whether this asserts should be context dependant 
} 

class OtherClass{ 
    ~OtherClass(){ 
     MyClass m; //this should assert 
     f();  //this should too; 
    } 
} 

int main() 
{ 
    MyClass m; //this should not assert 
    f();   //this should also not assert 
} 

Ein Versuch könnte sein:

assert(!std::uncaught_exception()); 

aber das würde nur funktionieren, wenn der destructor wegen einer Ausnahme aufgerufen wird, nicht, wenn es aufgerufen wird, weil das Objekt des Gültigkeitsbereich ging.

Answer 1

Sie können dies nicht erkennen und Sie möchten nicht. Es geht nicht um deine Klasse. Wenn dich jemand von noexcept destructor anruft, fängt er Ausnahmen

Answer 2

Sie können nicht feststellen, wie Ihre Funktion aufgerufen wird, es sei denn, Sie stellen die Informationen für die Anrufer bereit.

Auch, wie ich erinnere, Visual C++ nie implementiert std::uncaught_exception, so wäre das nicht gut (für tragbaren Code), auch wenn es bekannt war, dass kein Destruktor try Block aufgerufen.

Es ist jedoch trivial zu erkennen, ob ein Bereich aufgrund einer Ausnahme beendet wird oder nicht.

Setzen Sie diesen Bereich einfach in einen try-Block; Dafür ist es da.

Zum Beispiel

class Transaction 
{ 
private: 
    bool failed_; 
    Transaction(Transaction const&); // deleted 
    Transaction& operator=(Transaction const&); // deleted 

public: 
    void fail() { failed_ = true; } 

    void commit() { ... } 

    // More functionality, then 

    ~Transaction() 
    { 
     if(failed_) { rollback(); } 
    } 

    Transaction(): failed_(false) {} 
}; 

void foo() 
{ 
    Transaction transaction; 

    try 
    { 
     // blah blah 
    } 
    catch(...) 
    { 
     transaction.fail(); 
     throw; 
    } 
} 

Haftungsausschluss: Ich habe nicht dieses Muster so kann nicht bezeugen, wie praktisch es ist verwendet.