Указатель функции-члена С++ с разными аргументами - или это все равно плохо?

Оборачивать алгоритм в функтор — правильный подход, а std::function — хороший функтор, предоставляемый стандартной библиотекой.

Но использование boost::bind или даже std::bind, как предлагает Томек, действительно уродливо, IMO, и быстро выходит из-под контроля при связывании нескольких аргументов.

Если у вас есть последний компилятор, вы можете вместо этого использовать лямбду, что делает пример Томека похожим на:

std::function<void(Object*)> f  =
    [](Object* const that){ that->memberFnNoArg(); };

int int_value = 22;
std::function<void(Object*)> f2 =
    [int_value](Object* const that){ that->memberFnIntArg(int_value); };

Object o;
f(&o);
f2(&o);

Есть несколько символов для настройки лямбды, но синтаксис доступа к членам чрезвычайно естественен, и очевидно, как вы вносите изменения.

Конечно, вы можете сделать параметр ссылкой на объект, если очень хотите, но я предпочитаю здесь указатели.

Взгляните на std::function и std::bind, кажется, они идеально подходят для того, что вам нужно.

РЕДАКТИРОВАТЬ:

std::function<void(Object &)> f = &Object::memberFnNoArg;
std::function<void(Object &)> f2 = std::bind(&Object::memberFnWithIntArg, _1, 22);

Object o;
f(o);
f2(o);

должно работать из коробки, насколько я помню. Это то, что тебе надо?

Вы можете использовать функцию шаблона varadic:

template <typename... Args>
void process(void (Object::*func)(Args...),Args... args)
{
    Object object;

    // loops, called several times, ...
    (object.*func)(args...);
}

Вот полный пример:

#include <iostream>

struct Object
{
    void memberFnNoArg()
    {
      std::cout << "Object::memberFnNoArg()\n";
    }

    void memberFnWithIntArg(int arg)
    {
      std::cout << "Object::memberFnWithIntArg(" << arg << ")\n";
    }

    void memberFnWithFloatArg(float arg)
    {
      std::cout << "Object::memberFnWithFloatArg(" << arg << ")\n";
    }
};

template <typename... Args>
void process(void (Object::*func)(Args...),Args... args)
{
    Object object;

    // loops, called several times, ...
    (object.*func)(args...);
}

int main()
{
  process(&Object::memberFnNoArg);
  process(&Object::memberFnWithIntArg,5);
  process(&Object::memberFnWithFloatArg,2.7F);
  return 0;
}

Один из способов, который я вижу, - это использовать переменные аргументы (почти как printf, sprintf делает это). (Или, может быть, с библиотеками stdc, передавая список разных типов.)

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

Ниже приведен простой (не членский) пример того, как получить переменные аргументы (функции-члены будут работать точно так же). См. stdarg.h.

typedef void (*var_function)(int typearg, ...);

void print_arg(int typearg, ...)
{
  va_list ap;
  int i;

  va_start(ap, typearg); 

  if (typearg==1) { // int 
     int i= va_arg(ap, int);
     printf("%d ", i);
  }
  else 
  if (typearg==2) { // float 
     float f= va_arg(ap, float);
     printf("%f ", f);
  }
  else 
  if (typearg==3) { // char *
     char *s= va_arg(ap, char *);
     printf("%s ", s);
  }

     ....

  va_end(ap);
}

// calling function with different types
int main()
{
   print_arg(1, 999);
   print_arg(2, 3.1415926);
   print_arg(3, "Hello");
   ....
   process(print_arg, 3, "via pointer);

Похоже на packaged_task. Также ознакомьтесь с предложением Томека.

Хотя в реальной жизни я бы задал много вопросов о том, зачем вам это вообще нужно. Возможно, ваша работа может быть лучше освещена с помощью std::future или другого средства более высокого уровня,

Не может ли каждая функция (memberFn**) быть членом классов аргументов?

class BaseArg
{
  virtual void Fn() = 0;
};

class IntArg : public BaseArg
{
  void Fn();
};

class FloatArg : public BaseArg
{
  void Fn();
};


void function()
{
    int mode = getModeFromSomewhere();
    BaseArg* pArg;

    if ( mode ... ){
      pArg = new IntArg( 33 );
    }
    else {
      pArg = new FloatArg( 66.6 );
    }

    pArg->Fn();  // Call the right function without a switch
                 // and without knowing the arguments

}

То же, что и другие ответы, но для отображения методов-членов:

#include <iostream>
class Object
{
public:
    void memberFnNoArg()
    {
        std::cout << "Object::memberFnNoArg()\n";
    }

    void memberFnWithIntArg(int arg)
    {
        std::cout << "Object::memberFnWithIntArg(" << arg << ")\n";
    }

    void memberFnWithFloatArg(float arg)
    {
        std::cout << "Object::memberFnWithFloatArg(" << arg << ")\n";
    }
    bool memberFnWithBoolReturn(int)
    {
        return true;
    }
    template <typename... Args>
    void process(void (Object::*func)(Args...),Args... args);
    // overload process
    template <typename... Args>
    bool process(bool (Object::*func)(Args...),Args... args);
};
template <typename... Args>
void  process( void (Object::*func)(Args...),class Object* obj,Args... args)
{

    (obj->*func)(args...);
}
template <typename... Args>
bool  process( bool (Object::*func)(Args...),class Object* obj,Args... args)
{
    return ((obj->*func)(args...)) ;

}
int main()
{
    Object object;
    process(&Object::memberFnNoArg,&object);
    process(&Object::memberFnWithIntArg,&object,5);
    process(&Object::memberFnWithFloatArg,&object,2.7F);
    // overloaded process
    printf("%d\n",process(&Object::memberFnWithBoolReturn,&object,1));

    return 0;
}