Dotaz: C++ callback

[__blr__]

Zdravím,

potřeboval bych implementovat jednoduchou epoll smyčku, kdy ke každému deskriptoru potřebuju uložit callback. Jak známo, pokud nebudu používat statické metody, není možné použít &trida::metoda.

Dohledal jsem mnoho implementací "delegation/c++ method callback" z různých dob na různých verzích C++.

Rád bych se zeptat, jak dnes, tady a teď řešit tuto problematiku.

Díky

Odpovědi

[.]

A to "potřebuju" znamená co?

[rastos]

Metóda nejakej triedy v C++ je vlastne obyčajná C funkcia, ktorá okrem obyčajných parametrov dostane jeden parameter navyše: this. Ja som stará škola, ale urobil by som jednoducho mapu, kde kľúčom je deskriptor a hodnotou je pointer na funkciu.

A pokiaľ treba funkcii "odovzdať this", tak by hodnotou v tej mape nebol pointer na funkciu, ale štruktúra, v ktorej je jeden pointer na objekt (,ktorého metódu treba zavolať) a jeden pointer na funkciu.

[luky]

https://en.cppreference.com/w/cpp/utility/functional/invoke

[Andrej]

Jak známo, pokud nebudu používat statické metody, není možné použít &trida::metoda.

Huh? A tohle je "známo" odkdy? Že jsem to nějak nepostřehnul… Tady jsou "nestatické" metody a &třída::metoda:

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

class BunchOfCallbacks {
 public:
  BunchOfCallbacks(std::string state) : state_(std::move(state)) {}

  void Callback1(const std::string& message) const {
    std::cout << "Callback1 (" << state_ << "): " << message << std::endl;
  }
  void Callback2(const std::string& message) const {
    std::cout << "Callback2 (" << state_ << "): " << message << std::endl;
  }

 private:
  const std::string state_;
};

int main() {
  const std::tuple<BunchOfCallbacks,
                   void (BunchOfCallbacks::*)(const std::string&) const>
      callbacks[]{
          {BunchOfCallbacks{"first state"}, &BunchOfCallbacks::Callback1},
          {BunchOfCallbacks{"second state"}, &BunchOfCallbacks::Callback2},
      };

  for (const auto& bunch_callback : callbacks) {
    const auto& bunch{std::get<0>(bunch_callback)};
    const auto callback{std::get<1>(bunch_callback)};

    (bunch.*callback)("Yay! I can select a callback!");
  }
}

[xkucf03]

Bývá problém to předat do API nějaké céčkovské knihovny, ne?

Tam to často řeší tak, že kromě (statické) funkce lze předat i libovolný ukazatel, který se pak použije jako parametr při volání té funkce (tzn. tohle je způsob jak tam dostat to this nebo nějaký kontext)

[Andrej]

Máš pravdu, (implicitní) požadavek na interoperabilitu s C jsem tady úplně přehlédl. Ano, tam by se to muselo řešit jinak.

Problém totiž je, že member pointer je dost podivná věc. Například sizeof(void (BunchOfCallbacks::*)(const std::string&)) je asi tak 16, což zjevně neodpovídá pointeru, se kterým by mohlo pracovat přímo C.

(Důvod pro velikost member pointeru nějak souvisí s tím, že skrz něj musí správně fungovat taky virtuální metody. Což je u tříd bez virtuálních metod celkem jedno, ale ta implementace už je zkrátka taková.)

Když to má spolupracovat s C, asi bych ten callback napsal jako virtuální metodu, tj. každý typ callbacku by byl třída. Tam se pak dá předat tomu C nějaký void* a vhodný C++ wrapper (viditelný z C) ho může interpretovat jako ukazatel na toho abstraktního předka a zavolat jeho virtuální metodu.

[Andrej]

Inu, epoll() neznám, takže příklad s epoll() tady narychlo nesesmolím, ale takhle by mohla (obecně) vypadat ta spolupráce s C (tady konkrétně s pthread):

#include <errno.h>
#include <pthread.h>
#include <string.h>
#include <iostream>

namespace {
struct Callback {
  virtual void* call() = 0;
};

class ThreadWrapper {
  pthread_t thread_;

 public:
  ThreadWrapper(void* (*start_routine)(void*), void* arg) {
    if (-1 == pthread_create(&thread_, nullptr, start_routine, arg)) {
      throw errno;
    }
  }
  ~ThreadWrapper() {
    if (-1 == pthread_join(thread_, nullptr)) {
      std::cerr << "Join failed!\n";
    }
  }
};

void* ThreadBody(void* arg) { return static_cast<Callback*>(arg)->call(); }
}  // namespace

int main() {
  struct Callback1 : public Callback {
    void* call() override {
      std::cout << "I'm Callback 1!\n";
      return nullptr;
    }
  } callback1;
  struct Callback2 : public Callback {
    void* call() override {
      std::cout << "I'm Callback 2!\n";
      return nullptr;
    }
  } callback2;

  try {
    ThreadWrapper t1(ThreadBody, &callback1);
    ThreadWrapper t2(ThreadBody, &callback2);
  } catch (int e) {
    std::cerr << strerror(e) << std::endl;
  }
}

To^^^ pochopitelně vyžaduje -lpthread.

(Jasně, používat takhle v C++ pthread je nesmysl, protože C++ má už dávno (od dob Rapperswilu) na vlákna vhodnější abstrakce, nicméně tohle je míněno jako příklad na "callback mezi C a C++".)

[Kojot]

std::function

[Jardík]

V čem je vlastně problém? V epoll_data můžeš mít vlastní pointer, to ti stačí. Můžeš si dynamicky naalokovat klidně std::function, kde budeš mít cokoliv, pointer předáš při přidávání deskriptoru v epoll_event::data, po volání epoll_wait tento pointer dostaneš, přetypuješ na pointer na std::function, dereferencuješ a zavoláš. Nebo místo alokace std::function můžeš naalokovat strukturu, kde bude ukazatel na objekt a ukazatel na funkci a pak funkci zavoláš na ten objekt.