9

我创建了一个 Timer 类，它必须在计时器到期时调用回调方法。目前我让它与普通函数指针一起工作（它们被声明为 void (*)(void)，当 Elapsed 事件发生时，函数指针被调用。

是否可以使用也具有签名 void (AnyClass::*)(void) 的成员函数做同样的事情？

谢谢小伙伴。

编辑：此代码必须在 Windows 和实时操作系统（VxWorks）上工作，所以不使用外部库会很棒。

EDIT2：可以肯定的是，我需要的是有一个 Timer 类，它在没有参数的“AnyClass.AnyMethod”的构造函数中接受一个参数并返回 void。我必须存储这个参数，后者在代码的一个点中只执行这个变量指向的方法。希望是明确的。

4

5 回答 5

9

依赖关系，依赖关系......是的，当然 boost 很好，mem_fn 也很好，但你不需要它们。然而，调用成员函数的语法是邪恶的，所以一点模板魔法会有所帮助：

   class Callback
   {
   public:
      void operator()() { call(); };
      virtual void call() = 0;
   };

   class BasicCallback : public Callback
   {
      // pointer to member function
      void (*function)(void);
   public:
      BasicCallback(void(*_function)(void))
          : function( _function ) { };
      virtual void call()
      { 
          (*function)();
      };
   };   

   template <class AnyClass> 
   class ClassCallback : public Callback
   {
      // pointer to member function
      void (AnyClass::*function)(void);
      // pointer to object
      AnyClass* object;        
   public:
      ClassCallback(AnyClass* _object, void(AnyClass::*_function)(void))
          : object( _object ), function( _function ) { };
      virtual void call()
      { 
          (*object.*function)();
      };
   };

现在您可以使用 Callback 作为回调存储机制，这样：

void set_callback( Callback* callback );
set_callback( new ClassCallback<MyClass>( my_class, &MyClass::timer ) );

和

Callback* callback = new ClassCallback<MyClass>( my_class, &MyClass::timer ) );

(*callback)();
// or...
callback->call();
于 2010-01-27T15:03:20.117 回答
4

我用于相同目的的最佳解决方案是boost::signal或boost::function库（取决于您是否需要单个回调或多个回调），以及boost::bind以实际注册回调。

class X {
public:
   void callback() {}
   void with_parameter( std::string const & x ) {}
};
int main()
{
   X x1, x2;
   boost::function< void () > callback1;

   callback1 = boost::bind( &X::callback, &x1 );
   callback1(); // will call x1.callback()

   boost::signal< void () > multiple_callbacks;
   multiple_callbacks.connect( boost::bind( &X::callback, &x1 ) );
   multiple_callbacks.connect( boost::bind( &X::callback, &x2 ) );
   // even inject parameters:
   multiple_callbacks.connect( boost::bind( &X::with_parameter, &x1, "Hi" ) );

   multiple_callbacks(); // will call x1.callback(), x2.callback and x1.with_parameter("Hi") in turn
}
于 2010-01-27T14:49:06.447 回答
2

也许标准的mem_fun已经足够满足您的需求了。它是 STL 的一部分。

于 2010-01-27T14:55:24.377 回答
1

boost::function在这里看起来非常合适。

于 2010-01-27T14:49:29.270 回答
0

我假设这样的界面：

void Timer::register_callback( void(*callback)(void*user_data), void* user_data );

template<typename AnyClass, (AnyClass::*Func_Value)(void)>
void wrap_method_callback( void* class_pointer )
{
   AnyClass*const self = reinterpret_cast<AnyClass*>(class_pointer);
   (self->*Func_Value)();
}

class A
{
public:
   void callback()
   { std::cout << m_i << std::endl; }
   int m_i;
};

int main ()
{
   Timer t;
   A a = { 10 };
   t.register_callback( &wrap_method_callback<A,&A::callback>, &a );
}

我认为更好的解决方案是升级调用回调以使用 boost::function 或本土版本（如 Kornel 的回答）。但是，这需要真正的 C++ 开发人员参与，否则您很可能会引入错误。

我的解决方案的优点是它只是一个模板函数。不是很多都可能出错。我的解决方案的一个缺点是它可能会通过void*来回转换来分割你的班级。请注意，只有AnyClass*指针才能传递void*给回调注册。

于 2010-01-27T17:16:35.663 回答