std :: lier une fonction normale mais avec un épilogue

Question

J'ai un rappel particulier (défini dans certains 'C') qui doit être complété avec du travail supplémentaire qui ne fait pas partie de la fonction de rappel. Il va quelque chose comme ça ...

typedef void (*callback_func)(int); 
extern int set_callback(callback_func cb); 

Dans mon code C++, je dois SET_VALUE une promesse qui est définie en dehors de la portée du rappel, dans ma classe. Donc, je devrais capturer la variable de membre std :: promise ou bien ce et l'envoyer au rappel, puis le définir une fois que le rappel a été appelé, seulement que le compilateur ne l'aime pas. Je le fais de cette façon,

set_callback([this](int x) { 
    // some code ... 
    prom.set_value(true); 
}); 

est Ci-dessous l'erreur snipped:

error: no matching function for call to 'set_callback' 
     set_callback([this](int var) { 
     ^~~~~~~~~~~~~~~~~~~~~~~~~ 
note: candidate function not viable: no known conversion from '(lambda at xxx ' to 'callback_func' 
      (aka 'void (*)(int)') for 1st argument 

Je me rends compte que, je dois en quelque sorte « lier » la fonction régulière pour rendre la fonction de rappel d'un std :: fonction , mais je ne suis pas sûr de la manière d'accomplir cela - pour ne pas mentionner l'envoyer un paramètre et exécuter l'épilogue. S'il vous plaît suggérer, merci!

Answer 1

Les lambdas ne peuvent se désintégrer aux pointeurs de fonction que si la liste de capture est vide. En effet, le code

[this](int x) { 
    // some code ... 
    prom.set_value(true); 
} 

est à peu près équivalente à

struct SomeLambdaName { 
    MyCapture self; 

    auto operator()(int x) const { 
     // some code ... 
     self.prom.set_value(true); 
    } 
}; 

D'autre part, les pointeurs de fonction ne sont que: les pointeurs. Un pointeur vers l'adresse de la fonction à appeler.

En C++, une fonction membre:

struct MyClass { 
    int i; 
    int add_x(int x) { return i = i + x; } 
}; 

est à peu près comme dans le code C (dépendant de l'implémentation):

int add_x(MyClass *self, int x) { return self->i = self->i + x; } 

---

Si le code C peut être modifié pour prendre void * pour contenir des données arbitraires, cela peut être fait:

typedef void (*callback_func)(int, void * data); 
extern int set_callback(callback_func cb); 

set_callback([](int x, void * data) { 
    MyClass &self = *reinterpret_cast<MyClass *>(data); 
    // some code ... 
    self.prom.set_value(true); 
}); 

Sinon, vous devez avoir des objets statiques ou quelque chose de similaire.