Stratégie d'exécution différée en C++

Question

J'ai une implémentation de rappel dans laquelle une tierce partie inconnue appelle un pointeur de fonction dans mon code. Cependant, un problème dans plusieurs langues déclenche le code après le retour d'une fonction. Par exemple, lorsqu'un rappel est appelé et que je dois supprimer l'objet appelant (et, dans ce cas, le ré-initialiser), le retour du rappel entraînerait une exception.

En supposant que je ne puisse pas connecter et que je ne possède pas/ne puisse pas modifier le code appelant le rappel, quelle est la meilleure façon d'exécuter du code après le retour d'une fonction?

La seule façon réelle de faire cela est de mettre en place une sorte de machine d'état et de faire vérifier par un thread de travail l'état. Cependant, le problème que je prévois avec ceci est celui d'une condition de concurrence, où un rappel est appelé entre le moment où le rappel de réinitialisation revient et le point où l'objet appelant est réinitialisé.

Y at-il une sorte de fonctionnalité que je ne connais pas, ou ce serait le moyen le plus efficace d'atteindre un tel résultat?

Answer 1

Cela nécessite C++ 11 ou plus récent. Mais voici comment je le ferais. Vous pouvez réécrire à utiliser des pointeurs de fonction à la place de telle sorte que cela fonctionne sur les anciennes versions C++

#include <functional> 
#include <iostream> 

#define CONCACT_IMPL(x , y) x##y 
#define CONCAT(x, y) CONCACT_IMPL(x, y) 
#define deffered(x) auto CONCAT(__deffered, __COUNTER__) = Defer(x); 

struct Defer { 
    Defer(std::function<void(void)> pFunc) : func(pFunc) {}; 
    std::function<void(void)> func; 
    virtual ~Defer(){ 
     func(); 
    } 
}; 

int main() { 

    deffered([]() { 
     std::cout << "deffered" << std::endl; 
    }); 

    std::cout << "now" << std::endl; 
} 

sorties ->

now 
deffered