Wie kann ich mich übergeben, ein C++ - lambda-um einen C-callback, der erwartet, dass ein Funktionszeiger und ein Kontext?

Ich versuche, registrieren Sie einen Rückruf in einer C-API, die verwendet die standard-Funktion-Zeiger+Kontext-Paradigma. Hier ist, was die api sieht wie folgt aus:

void register_callback(void(*callback)(void *), void * context);

Was ich wirklich gerne tun, ist in der Lage, registrieren Sie einen C++ - lambda als der Rückruf. Darüber hinaus möchte ich die lambda sein, eine, die erobert hat-Variablen (dh. kann nicht konvertiert werden, um eine gerade stateless std::function)

Welche Art von adapter code brauche ich, um schreiben zu können, registrieren Sie einen lambda-Ausdruck als callback?

während std::function<T> ist eine Art erasure-Mechanismus, der Lage, der einen lambda-Ausdruck, es ist nicht die lambda
Das ist fair. Habe die dicrepancy Sie daran hindern, die Frage zu verstehen? Gibt es da eine Möglichkeit, ich kann ihn neu schreiben?
es könnte sein, dass ich noch nicht gegeben, die Frage weiter gedacht, um ganz ehrlich mit Ihnen, aber Sie umschreiben könnte sagen, dass Sie müssen ziehen Sie den Funktionszeiger aus std::function<> lieber als aus einer lambda
Das hört sich großartig an. Gibt es eine Möglichkeit, ziehen Sie einen Rahmen dabei heraus? Eine Art von Zustand, ich konnte gehen, wie die Kontext-Zeiger auf die C-api?

InformationsquelleAutor Michael Bishop | 2013-12-11

c c++c++11 lambda

21

Den einfachen aporoach klebt man den lambda-Ausdruck in eine std::function<void()> ist gehalten, irgendwo. Möglicherweise ist es dem heap zugeordnet und lediglich verwiesen wird, die von der void* registriert mit der Einheit unter den Rückruf. Die callback-würden Sie dann einfach eine Funktion wie diese:
```
extern "C" void invoke_function(void* ptr) {
    (*static_cast<std::function<void()>*>(ptr))();
}
```
Beachten Sie, dass std::function<S> können-hold-Funktion, Objekte mit Zustand, z.B., lambda-Funktionen mit einer nicht-leeren erfassen. Sie konnte registrieren Sie einen Rückruf so:
```
register_callback(&invoke_function,
  new std::function<void()>([=](){ ... }));
```
InformationsquelleAutor Dietmar Kühl

Der effizienteste Weg ist, um voidify die lambda direkt.

#include <iostream>
#include <tuple>
#include <memory>

template<typename... Args, typename Lambda>
std::pair< void(*)(void*, Args...), std::unique_ptr<void, void(*)(void*)> > voidify( Lambda&& l ) {
  typedef typename std::decay<Lambda>::type Func;
  std::unique_ptr<void, void(*)(void*)> data(
    new Func(std::forward<Lambda>(l)),
    +[](void* ptr){ delete (Func*)ptr; }
  );
  return {
    +[](void* v, Args... args)->void {
      Func* f = static_cast< Func* >(v);
      (*f)(std::forward<Args>(args)...);
    },
    std::move(data)
  };
}

void register_callback( void(*function)(void*), void * p ) {
  function(p); //to test
}
void test() {
  int x = 0;
  auto closure = [&]()->void { ++x; };
  auto voidified = voidify(closure);
  register_callback( voidified.first, voidified.second.get() );
  register_callback( voidified.first, voidified.second.get() );
  std::cout << x << "\n";
}
int main() {
  test();
}

hier voidify nimmt eine lambda-und (Optional) eine Liste der Argumente und erzeugt einen traditionellen C-Stil callback -void* - pair-Mädchen. Die void* im Besitz einer unique_ptr mit einem speziellen deleter, damit die Ressourcen werden richtig gereinigt.

Den Vorteil, dies über eine std::function Lösung ist die Effizienz -- ich beseitigt Ebene des run-time-Dereferenzierung. Die Lebensdauer, dass der Rückruf gilt, ist auch klar, dass es in der std::unique_ptr<void, void(*)(void*)> zurückgegeben voidify.

unique_ptr<T,D>s moved in shared_ptr<T> wenn Sie möchten, eine komplexere Lebensdauer.

Den oben genannten Mischungen Lebensdauer mit Daten, und geben Sie die Löschung mit Dienstprogramm. Wir können es teilen:

template<typename... Args, typename Lambda>
std::pair< void(*)(void*, Args...), std::decay_t<Lambda> > voidify( Lambda&& l ) {
  typedef typename std::decay<Lambda>::type Func;
  return {
    +[](void* v, Args... args)->void {
      Func* f = static_cast< Func* >(v);
      (*f)(std::forward<Args>(args)...);
    },
    std::forward<Lambda>(l)
  };
}

Nun voidify nicht zuordnen. Einfach speichern Sie Ihre voidify für die Lebensdauer der callback übergeben Zeiger aufsecond als Ihre void* an der Seite der first Funktion Zeiger.

Wenn Sie brauchen, um zu speichern, dieses Konstrukt aus dem Stapel, die Umwandlung der lambda-Ausdruck ein std::function helfen kann. Oder verwenden Sie die erste Variante vor.

Ich bin mir nicht sicher, ob ich beeindruckt oder entsetzt durch das Wort "voidified"

InformationsquelleAutor Yakk - Adam Nevraumont

Einer lambda-Funktion ist kompatibel mit C-callback-Funktion, solange es nicht erfassen Variablen.

Kraft, etwas neues zu alten mit dem neuen Weg nicht sinnvoll.

Wie wäre folgende altmodische Art und Weise?

typedef struct
{
  int cap_num;
} Context_t;

int cap_num = 7;

Context_t* param = new Context_t;
param->cap_num = cap_num;   //pass capture variable
register_callback([](void* context) -> void {
    Context_t* param = (Context_t*)context;
    std::cout << "cap_num=" << param->cap_num << std::endl;
}, param);

InformationsquelleAutor Hill

0

Sehr einfache Art und Weise zu verwenden, erhalten Sie eine lamda Funktion als C-Funktion Zeiger ist dieser:
```
auto fun=+[](){ //add code here }
```
finden Sie diese Antwort für ein Beispiel. https://stackoverflow.com/a/56145419/513481

InformationsquelleAutor janCoffee

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.