Question

我有几个功能。

void a();
bool b();
void c(int x, int y);

一个功能是什么样的。

void setListener(void * listenerCallback);

我必须将所有这些函数（a，b，c）作为“setListener”函数的参数发送。

setListener(&a);
setListener(&b);
setListener(&c);

如何在不重载setListener函数的情况下实现此目的？

我找到一个变种。虽然我认为他可能会引起记忆问题。但实际上它与Lundin的解决方案相同，只是没有结合。

typedef unsigned int varCallback;

enum callbackType {
    C_VOID,
    C_BOOL,
    C_VOID_INT_INT,
}

void setListener(varCallback callbackPointerAddress, callbackType type) {
    /// code
}

void a() {};
bool b() {};
void c(int x, int y) {};

setListener((varCallback)&a, C_VOID);
setListener((varCallback)&b, C_BOOL);
setListener((varCallback)&c, C_VOID_INT_INT);

Answer 1

当你标记这个C时，这里也是一个C解决方案（作为伪代码）：

typedef enum
{
  FPTR_VOID_VOID,
  FPTR_BOOL_VOID,
  FPTR_VOID_INT_INT
} Func_ptr_t;

typedef struct
{
  Func_ptr_t type;

  union
  {
    void(*void_void)();
    bool(*bool_void)();
    void(*void_int_int)(int, int);
  };  
} My_func_ptr_t;


My_func_ptr_t var = {FPTR_VOID_VOID, &a};
setListener(&var);

编辑：

（仍然认为这是伪的，我没有编译或测试过它）

void setListener (void * listenerCallback)
{
  const My_func_ptr_t* func_ptr;

  func_ptr = (const My_func_ptr_t*) listenerCallback;

  switch(func_ptr->type)
  {
    case FPTR_VOID_VOID:
    {
      func_ptr->void_void();
      break;
    }
    ...
  }
}

编辑2：

顺便说一下，应该注意的是，这是在C中一般传递几个函数指针的唯一方法。从一个函数指针到另一个指针类型的狂野类型转换是未定义的行为。

Answer 2

您可以尝试编写函数模板和函子。

示例：

void a();
bool b();
void c(int x, int y);

template<typename Fun>
void setListener(Fun listenerCallback);

template<typename Fun, typename TArg1, typename TAgr2, typename R>
struct Functor
{
     Fun   m_fun;
     TArg1 m_arg1;
     TArg2 m_arg2;
     Functor(Fun fun, TArg1 arg1, TArg2 arg2) 
         : m_fun(fun), m_arg1(arg1), m_arg2(arg2) {}
    R operator()()
    {
        return m_fun(arg1, arg2);
    }
};

Functor<void (*)(int,int), int, int, void> c_fun(c, 10, 20);

setListener(&a);
setListener(&b);
setListener(c_fun);

10和20是函数c(int, int)的参数。

注意：这不是非常通用的解决方案，这是针对此处提出的问题。

将几个回调作为函数参数发布

2 个答案: