Указатель функции-члена C++ на глобальный указатель функции

Вы можете использовать автономную функцию, которая вызывает оболочку, которая привязывает к ней ваш экземпляр. Вот грубый пример

#include <iostream>
#include <string>
#include <functional>

// global function which works
std::function<void(float, float)> memberCb;
void task_global(float x, float y) { memberCb(x, y); }
typedef void(*f_pointer)(float, float);


// try of using a member function
class BaseTask {
public:
    virtual void  task(float x, float y) = 0;
};


class ListeningTask :public BaseTask {
public:
    void  task(float x, float y) { printf("Called this member function with: %f %f\n", x, y); }
};

typedef void (BaseTask::*member_f_pointer)(float, float);

void callbackWrapper(BaseTask* t, float x, float y) { t->task(x, y); }

// the dll to use
class RegisterTask {
public:
    // no posibility to access or modify!
    void  subscribe(f_pointer fp) { 
        fp(1.0f, 2.0f); 
    }
    // just for demonstration how to use a member function pointer
    void  subscribeMemberDemo(member_f_pointer mfp) {  /*???*/ };
};



int main() {

    RegisterTask register_task{};

    ListeningTask listening_task{};
    memberCb = std::bind(&callbackWrapper, &listening_task, std::placeholders::_1, std::placeholders::_2);
    register_task.subscribe(task_global);

    return 0;
}

Примечание

Основываясь на комментарии, я не уверен, что все это работает в MSVC2010, так как у меня нет этой версии компилятора. Но элементарная поддержка C++11 должна быть.

Изменить

Я не уверен, что это то, что вам нужно, но решит ли это вашу проблему?

void callbackWrapper(const std::list<BaseTask*> &taskList, float x, float y) {
    for (auto t : taskList)
        t->task(x, y); 
}

int main() {

    RegisterTask register_task{};

    std::list<BaseTask*> taskList;
    for (int i = 0; i < 4; ++i)
        taskList.push_back(new ListeningTask);
    memberCb = std::bind(&callbackWrapper, taskList, std::placeholders::_1, std::placeholders::_2);
    register_task.subscribe(task_global);

    return 0;
}

Редактировать 2 Хорошо, я понял, что вы хотите. Лучшее, что я могу придумать, не разбрызгивая ваш код глобальными функциями вручную, — это магия шаблонов. Однако обратите внимание, что он не такой гибкий, как вам хотелось бы, потому что вам нужно привязать эти методы во время компиляции. Если вам нужно добавить их во время выполнения, вы, вероятно, можете использовать тот же прием, но без шаблонов. Просто поместите все объекты std::function в вектор и заверните его в синглтон или что-то подобное.

#include <iostream>
#include <string>
#include <functional>
#include <list>


/* Simulated DLL */
typedef void(*f_pointer)(float, float);
class RegisterTask {
public:
    void  subscribe(f_pointer fp) {
        fp(1.0f, 2.0f);
    }
};



/* Static function generator to ease the pain to define all of them manually */
template<unsigned int T>
std::function<void(float, float)> &getWrapper() {
    static std::function<void(float, float)> fnc;
    return fnc;
}

/* Same here */
template<unsigned int T>
void task_global(float x, float y) { getWrapper<T>()(x, y); }



class BaseTask {
public:
    virtual void  task(float x, float y) = 0;
};
class ListeningTask :public BaseTask {
public:
    ListeningTask(int taskNum) : m_taskNum(taskNum) {}
    void  task(float x, float y) { printf("Called this member of task %d function with: %f %f\n", getTaskNum(), x, y); }
    int getTaskNum() const { return m_taskNum; }
private:
    int m_taskNum;
};


/* Context injector */
void callbackWrapper(BaseTask* t, float x, float y) {
    t->task(x, y);
}

/* Convenience function to bind an instance to a task */
template<unsigned int T>
void bindTask(ListeningTask* t) {
    getWrapper<T>() = std::bind(&callbackWrapper, t, std::placeholders::_1, std::placeholders::_2);
}

int main() {

    RegisterTask register_task{};

    auto task0 = new ListeningTask(1337);
    auto task1 = new ListeningTask(1984);
    auto task2 = new ListeningTask(42);

    bindTask<0>(task0);
    register_task.subscribe(task_global<0>);

    bindTask<1>(task1);
    register_task.subscribe(task_global<1>);

    bindTask<2>(task2);
    register_task.subscribe(task_global<2>);

    return 0;
}

Запустите демонстрацию кода

ответ pokey909 совершенно великолепен, но если у вас даже нет доступа к std::function и std::bind, мы можем взломать наш путь Это.

Суть подхода в том, что мы собираемся определить класс-шаблон с неявным преобразованием в желаемый тип функции. Недостатком является то, что каждая новая дополнительная оболочка требует объявления нового типа.

// assumes two function arguments
template<class Ret, class Mem, class Arg1, class Arg2, int>
struct MemBind
{
    typedef Ret(Mem::*mem_fn_type)(Arg1, Arg2);
    static void Set(mem_fn_type _fn, Mem* _instance)
    {
        fn = _fn;
        instance = _instance;
    }

    static Ret DoTheThing(Arg1 first, Arg2 second)
    {
        return ((*instance).*fn)(first, second);
    }

    typedef Ret(*fn_type)(Arg1, Arg2); 
    operator fn_type ()
    {
        return DoTheThing;
    }

    static mem_fn_type fn;
    static Mem* instance;
};

Учитывая некоторую структуру Foo с нашим желаемым обратным вызовом:

struct Foo
{
    void Bar(float a, float b)
    {
        std::cout << "Foo::Bar(float, float) " << a << " , " << b << std::endl;
    }
};

Мы должны определить наши статические члены:

typedef MemBind<void, Foo, float, float, 0> MemBindZero;
template<> Foo* MemBindZero::instance = nullptr;
template<>  void(Foo::*MemBindZero::fn)(float, float)  = nullptr;

У нас может быть вызывающий объект, который принимает указатель на функцию:

void Caller(void(*_fn)(float, float))
{
    _fn(42.0, 1337.0);
}

Ключевым моментом здесь является то, что MemBind имеет неявное преобразование в желаемый тип функции. 0 в typedef для MemBindZero позволяет нам повторно использовать те же типы для других аргументов, но увеличивать счетчик до 1 при использовании. Я думаю, что вы, вероятно, могли бы заменить его макросом __COUNTER__ или чем-то подобным, но это было бы нестандартно, поэтому я сделал это вручную.

Теперь следующим шагом будет создание экземпляра MemBindZero, затем установка элементов static и, наконец, передача нашего экземпляра в Caller:

 Foo f;
 MemBindZero bound;
 bound.Set(&Foo::Bar, &f);
 Caller(bound);

Демо

В демо я завернул инициализацию статического члена в более удобный макрос:

#define MEMBIND(RET, CLASS, ARG1, ARG2, COUNT, ALIAS) \
typedef MemBind<RET, CLASS, ARG1, ARG2, COUNT> ALIAS; \
template<> CLASS * ALIAS::instance = nullptr; \
template<>  RET(CLASS::*ALIAS::fn)(ARG1, ARG2)  = nullptr;

Чтобы я мог назвать это так:

MEMBIND(void, Foo, float, float, 0, MemBindZero)
MEMBIND(void, OtherFoo, float, float, 1, MemBindOne)