Convertir pointeur de fonction C++ à c de pointeur de fonction

Si je me souviens correctement, Seulement des méthodes statiques d'une classe peut être consulté via la "normale" C le pointeur de fonction de la syntaxe. Donc, essayez de la rendre statique. Le pointeur à une méthode d'une classe a besoin d'informations supplémentaires, telles que "l'objet" (ce) qui n'a pas de sens pour un pur C méthode.

La FAQ montré ici a une bonne explication et un possible (laid) la solution à votre problème.

OriginalL'auteur fritzone

Vous ne pouvez pas passer un pointeur de fonction à un non-fonction membre statique. Ce que vous pouvez faire est de créer un statique ou fonction globale qui fait l'appel à un paramètre instance.

Voici un exemple que je trouve utile qui utilise une classe d'assistance avec deux membres: une fonction wrapper et une fonction de rappel qui appelle le wrapper.

template <typename T>
struct Callback;

template <typename Ret, typename... Params>
struct Callback<Ret(Params...)> {
    template <typename... Args>
    static Ret callback(Args... args) { return func(args...); }
    static std::function<Ret(Params...)> func;
};

//Initialize the static member.
template <typename Ret, typename... Params>
std::function<Ret(Params...)> Callback<Ret(Params...)>::func;

Cela, vous pouvez stocker n'importe quel appelable, même les non-fonctions membres statiques (à l'aide de std::bind) et le convertir en un c-pointeur à l'aide de la Callback::callback fonction. E. g:

struct Foo {
    void print(int* x) { //Some member function.
        std::cout << *x << std::endl;
    }
};

int main() {
    Foo foo; //Create instance of Foo.

    //Store member function and the instance using std::bind.
    Callback<void(int*)>::func = std::bind(&Foo::print, foo, std::placeholders::_1);

    //Convert callback-function to c-pointer.
    void (*c_func)(int*) = static_cast<decltype(c_func)>(Callback<void(int*)>::callback);

    //Use in any way you wish.
    std::unique_ptr<int> iptr{new int(5)};
    c_func(iptr.get());
}

OriginalL'auteur Snps

J'ai une idée (pas tout à fait conforme à la norme, comme extern "C" est manquant):

class MainWindow;

static MainWindow* instance;

class MainWindow
{
public:
  MainWindow()
  {
    instance = this;

    registerCallback([](int* arg){instance->...});
  }
};

Vous aurez des problèmes si plusieurs instances de MainWindow sont instanciés.

OriginalL'auteur user1095108

@Snp réponse est parfait! Mais comme @DXM mentionné qu'il peut détenir qu'un seul rappel. J'ai amélioré un peu, maintenant, il peut garder de nombreux rappels du même type. C'est un peu étrange, mais fonctionne parfaitement:

 #include <type_traits>

template<typename T>
struct ActualType {
    typedef T type;
};
template<typename T>
struct ActualType<T*> {
    typedef typename ActualType<T>::type type;
};

template<typename T, unsigned int n,typename CallerType>
struct Callback;

template<typename Ret, typename ... Params, unsigned int n,typename CallerType>
struct Callback<Ret(Params...), n,CallerType> {
    typedef Ret (*ret_cb)(Params...);
    template<typename ... Args>
    static Ret callback(Args ... args) {
        func(args...);
    }

    static ret_cb getCallback(std::function<Ret(Params...)> fn) {
        func = fn;
        return static_cast<ret_cb>(Callback<Ret(Params...), n,CallerType>::callback);
    }

    static std::function<Ret(Params...)> func;

};

template<typename Ret, typename ... Params, unsigned int n,typename CallerType>
std::function<Ret(Params...)> Callback<Ret(Params...), n,CallerType>::func;

#define GETCB(ptrtype,callertype) Callback<ActualType<ptrtype>::type,__COUNTER__,callertype>::getCallback

Maintenant, vous pouvez simplement faire quelque chose comme ceci:

typedef void (cb_type)(uint8_t, uint8_t);
class testfunc {
public:
    void test(int x) {
        std::cout << "in testfunc.test " <<x<< std::endl;
    }

    void test1(int x) {
        std::cout << "in testfunc.test1 " <<x<< std::endl;
    }

};

cb_type* f = GETCB(cb_type, testfunc)(std::bind(&testfunc::test, tf, std::placeholders::_2));

cb_type* f1 = GETCB(cb_type, testfunc)(
                std::bind(&testfunc::test1, tf, std::placeholders::_2));


f(5, 4);
f1(5, 7);

OriginalL'auteur Evgeniy Alexeev