Как я могу передать указатель функции-члена в функцию, которая принимает обычный указатель функции?

Чтобы вызвать функцию-член с помощью указателя, вам нужны два указателя: указатель на саму функцию и указатель на объект, который должен быть this. Ваш Game::idle API не поддерживает такое использование. Вам нужно изменить его так, чтобы он передавал хотя бы один аргумент (условно типа void *) обратному вызову. Затем вы можете использовать следующий шаблон:

struct Player
{
        // ...
        void kill();

        // ...
        static void call_kill(void *self);
};

void Player::call_kill(void *self)
{
    static_cast<Player *>(self)->kill();
}

struct Game
{
    static void idle(void (*)(void *), void *, int);
};

void Game::idle(void (*callback)(void *), void *arg, int ticks)
{
    // ...
    callback(arg);
    // ...
}

void kill_player_delayed(Player *p, int ticks)
{
    Game::idle(Player::call_kill, static_cast<void *>(p), ticks);
}

Вы должны написать статический метод call_X для каждого метода экземпляра X, который вы хотите вызвать.

Альтернативный подход, который, возможно, более идиоматичен и гибок в C++ и включает в себя менее явно написанный код, но имеет более высокие затраты времени выполнения (три косвенных вызова функций и цикл без выделения памяти для кучи на вызов вместо одного косвенного вызова функции). ), состоит в том, чтобы Game::idle принимать объект определенного класса с виртуальным методом обратного вызова. Затем этому классу предоставляется подкласс шаблона, который может вызывать все, что реализует operator(), например результат std::bind.

struct Runnable { virtual ~Runnable(); virtual void invoke() = 0; };

template <typename T> struct TRunnable : Runnable {
    TRunnable(T target) : target(target) {}
    void invoke() { target(); }
private:
    T target;
};
template <typename T> TRunnable<T>* make_Runnable(T obj)
{ return new TRunnable<T>(obj); }

struct Game
{
    static void idle(Runnable *, int);
};

void Game::idle(Runnable *r, int ticks)
{
    // ...
    r->invoke();
    delete r;
    // ...
}

struct Player
{
    // ...
    void kill();
    // ...
};

void kill_player_delayed(Player *p, int ticks)
{
    Game::idle(make_Runnable(std::bind(&Player::kill, p)), ticks);
}

Вы не можете заставить Game::idle принимать результат std::bind напрямую, потому что тип этого объекта не указан (и зависит от того, как вы вызываете std::bind), поэтому его можно использовать только в качестве аргумента для вызова функции template. Вызов виртуального метода для класса адаптера — единственный способ сохранить Game::idle скомпилированный вне очереди и по-прежнему позволять ему использовать объекты связанного вызова.

При любом подходе остерегайтесь проблем со временем жизни объекта. В частности, если Game::idle не вызывает свой обратный вызов перед возвратом, необходимо убедиться, что и исходный объект, и (во втором подходе) объект, возвращенный make_Runnable выжить, пока не сработает обратный вызов. Вот почему make_Runnable использует new.

В другом ответе упоминается, что вам нужны два указателя. Однако C++ уже поставляется с контейнерами для этого, поэтому их использование значительно упростит ваш код. (В C++03 некоторые из элементов std:: ниже были std::tr1::).

Образец кода:

#include <iostream>
#include <functional>

struct Game 
{ 
    static void idle( std::function<void()> func, int x )
        { std::cout << "x = " << x << "\n"; func(); }
};

struct Player
{
     void death() { std::cout << "player.death\n"; }
     void kill() { Game::idle( std::bind(&Player::death, this), 48 ); }
};

int main()
{
    Player p;
    p.kill();
}

Примечание на всю жизнь: std::bind связывается по значению. Использование *this означает, что копия Player создается и сохраняется в объекте std::function, при необходимости копируется вместе с ним.

Использование this означает, что объект функции хранит указатель, поэтому, если вы действительно сохраняете объект функции в Game::idle, вы должны позаботиться о том, чтобы этот Player не был уничтожен, прежде чем удалять этот объект функции из списка Game::idle.

Поскольку мне действительно не нравится ответ, который приводит void* к другим объектам (почти никогда не требуется в C++!), И никто не опубликовал ответ, используя предложения в комментариях, я собираюсь предложить это.

Используйте шаблонный тип для обратного вызова!

Так:

class Game{
    template<typename Func>
    static void idle(Func &&func, int i){
        // game stuff
        func();
        // other game stuff
    }
};

Тогда вы не потеряете всю свою безопасность типов (приведение void*), и это должно быть самым быстрым решением.

Кроме того, когда вы назначаете указатель на функцию, вы можете изменить код, чтобы сделать его более читаемым в этом случае:

void Player::kill(){
    Game::idle([this](){this->death();}, 48);
}

Это гораздо приятнее, чем писать правильный тип указателя на функцию.

Вы не можете сделать это просто потому, что указатель на [статическую] функцию является одним указателем sizeof void*. В противоположной функции-члене требуется дополнительная информация, например. два указателя: один для this, а другой для самой функции, поэтому указатель функции-члена имеет sizeof > sizeof(void*).

Поэтому у вас есть два варианта:

1. чтобы изменить подпись вашего idle() на этот void idle(void (*)(), void*, int);, чтобы вы могли каким-то образом передать this.
2. Или создайте статическую переменную, которая будет содержать указатель this. Но это предполагает, что только один death() может находиться в очереди ожидания в любой момент времени.

1) это то, что люди обычно делают в таких случаях.