Wie kann ich garantieren, dass die Lebensdauer eines Objekts der Dauer einer Mitgliedsfunktion entspricht?

Question

Ich habe Callbacks verwendet, um die Kopplung zwischen einigen C++ - Klassen zu reduzieren. Um Begriffe zu definieren: Ich rufe die Klasse an, die die Rückrufe durchführt, und die Klasse, die den Rückruf erhält, den Angerufenen. In der Regel (aber nicht notwendigerweise) besitzt der Angerufene den Anrufer. Der Anrufer hat vom Design her keine Kenntnis vom Angerufenen.

Ich stoße auf ein Problem in Bezug auf die Lebensdauer des Caller-Objekts: Es gibt keine Garantie, dass es nach jedem beliebigen Callback noch am Leben ist. Nehmen Sie dieses einfache Beispiel:

void caller::f() 
{ 
    /* Some work */ 
    if (...) 
    { 
     /* [1] Execute callback */ 
     _callee->callback(this); 
    } 
    /* [2] Some more work */ 
} 

Sagen Sie, dass der Angerufene dynamisch den Anrufer zugewiesen hat, und hat für den Rückruf registriert speziell für einen bestimmten Zustand zu warten, auftreten. Wenn dies der Fall ist, löscht der Angerufene den Anrufer aus dem Rückruf bei [1]. Wenn das der Fall ist, kehrt die Steuerung zu caller :: f zurück, aber this wurde gelöscht, und jeder Code bei [2] wird höchstwahrscheinlich abstürzen.

Im allgemeinen Fall kann der Aufrufer nichts über den Angerufenen annehmen. Es weiß nicht, ob der Angerufene this besitzt, oder ob es this freigeben kann, also würde ich einige allgemeine Mittel benötigen, um die Freigabe für den Bereich der Aufruffunktion des Aufrufers zu verhindern.

Ich glaube eine mögliche Lösung dreht sich um boost::shared_ptrs und enable_shared_from_this, obwohl ich es nie benutzt habe. Da diese Callbacks sehr häufig auf mobilen Geräten mit begrenzter Verarbeitungsleistung ausgeführt werden (40+ Mal pro Sekunde), mache ich mir auch Sorgen über den Overhead des Erstellens und Entlassens dieser vielen shared_ptrs.

Delegierung ist ein ziemlich häufiges Muster in Objective-C. Ich bin weit weniger vertraut mit gängigen C++ - Entwurfsmustern. Gibt es eine schnelle und einfache Lösung für dieses Problem? Wenn nicht, wie würde dieses Design normalerweise in C++ erreicht?

Answer 1

Gehen Sie voran und verwenden den gemeinsamen Zeiger, obwohl, wenn möglich, die Verwendung std::shared_ptr statt boost::shared_ptr. Es ist in der (aktuellen) Standardbibliothek, so dass keine unnötige Boost-Abhängigkeit hinzugefügt werden muss.Wenn Sie bereits Boost verwenden, ist das auch in Ordnung.

Sie haben nicht angegeben, über welche Art von Mobilgerät Sie sprechen, aber die Prozessoren in modernen Smartphones laufen mit Hunderten oder Tausenden von Megahertz, und sogar Low-Power-Telefone oft nur Java-Programme (mit Garbage Collection) fein. Geteilte Zeiger sind grundsätzlich Referenzzähler. Es ist keine ressourcenintensive Aktivität.

Wenn Ihr Gerät den Rückruf tatsächlich mehr als 40 Mal pro Sekunde ausführen kann, bezweifle ich, dass es Probleme mit freigegebenen Zeigern haben wird. Nicht vorzeitig für die Ausführungsgeschwindigkeit optimieren. Frühzeitig optimieren für Sicherheit und Gesundheit.

Answer 2

Wenn der Aufrufer delete s Aufrufer, wird Destruktor des Aufrufers aufgerufen. Dort sollten Sie sicherstellen, dass f fertig ist.

Ich vermute, bin f ein Thread ist, so würde einfachste Lösung sein:

thread:

running = true; 
while (!must_exit) 
    /* do something */ 

destuctor:

thread->must_exit = true; 
while (thread->running) 
    sleep(a_little); 
/* continue with destruction */ 

Wenn f kein Gewinde ist, das gleiche Prinzip kann gelten, wo f sein Objekt (und dadurch seinen Destruktor) weiß, wann es läuft und wann nicht.

---

Wenn Sie nicht mit einem destructor Ansatz gehen wollen, können Sie immer noch diese Funktionalität durch eine Funktion implementieren, die die Angerufenen Anrufe, f sagen, nie wieder laufen und warten, bis sie stoppt. Dann fährt der Angerufene mit dem Löschen des Anrufers fort.

So etwas wie folgt aus:

void caller::f() 
{ 
    if (being_deleted) 
     return; 
    running = true; 
    /* Some work */ 
    if (...) 
    { 
     /* [1] Execute callback */ 
     _callee->callback(this); 
    } 
    /* [2] Some more work */ 
    running = false; 
} 

void caller::make_f_stop() 
{ 
    being_deleted = true; 
    while (running) 
     sleep(a_little); 
} 

Answer 3

Die übliche Methode zur Umgehung von Code, die nicht mehr ausgeführt werden kann, ist das Auslösen einer Ausnahme. Dies sollte vom Angerufenen an dem Punkt erfolgen, an dem er normalerweise zum Anrufer zurückkehren würde, nachdem er den Anrufer gelöscht hat. Die Ausnahme würde am Ende der Funktion im Anrufercode abgefangen werden.

Ich kann nicht sagen, dass ich diese Lösung mag, aber ich denke, dass das von der ungewöhnlichen Situation des Angerufenen stammt, der den Anrufer besitzt.

Ich weiß nicht, wie intelligente Zeiger helfen würden, da niemand die zweite Kopie des Zeigers besitzen kann.