c++ - 如何在不引起循环依赖的情况下传递然后调用泛型回调函数

Question

无法创造性地缩短标题:)

我一直在使用以下解决方案的变体，但是我一直想知道是否有更好/更清洁的方法来实现它。我正在寻找非增强解决方案。不过，我们可以看看 boost 和 C++0x 的实现，因为它很快就会相关。

//Notice the use of template template parameter
template <template <typename> class Callback>   
class A {
   Callback <A> m_func;
   public:
     A (Callback <A>  func):  m_func (func) {}
     void call () { m_func(*this);}

};

template <typename T>
struct MYCallback
{
   void operator () (const T&t) {}

};


void Test()
{
   typedef A<MYCallback> AType;

   MYCallback<AType> callback;
   AType a (callback);
   a.call ();

}

另一种更简洁的方法是使用 tr1::function，它会随着新的标准化而失效：

#include <tr1/functional>


class A {
   std::tr1::function <void (const A&)>  m_func;
   public:
     template <class Callback>
     A (Callback func) :  m_func (func) {}

     void call () { m_func(*this);}

};

template <class T>
struct My_callback
{
   void operator () (const T&t) {}

};

void Test ()
{
   My_callback <A> c;
   A a (c);
   a.call ();
}

Answer 1

我始终相信 void* 是您想要优雅的朋友。

Answer 2

一种方法是使用派生类：

template <class Callback>   
class A {
   Callback m_func;
   public:
     A (Callback  func):  m_func (func){}
     void call () { m_func(*this);}

};

template <typename T>
struct MYCallback
{
   void operator () (const T&t) {}

};


struct AConcrete : public A<MYCallback<AConcrete> >
{
  template <class T>
  AConcrete(T t): A<MYCallback<AConcrete> > (t) {}
};

void Test()
{

   MYCallback<AConcrete> callback;
   AConcrete a (callback);
   a.call ();

}

PS：递归对于 C++ 模板来说很困难。

Answer 3

如果您只是在寻找清理建议，我建议将“My_c​​allback”设为普通类，而不是类模板。在这种情况下，它显然不需要成为模板。相反，如果 My_callback 只处理 A 实例，则将其应用运算符模板化或直接填写 A：

#include <tr1/functional>

class A {
   std::tr1::function <void (const A&)>  m_func;
   public:
     template <class Callback>
     A (Callback func) :  m_func (func) {}

     void call () { m_func(*this);}

};

struct My_callback
{
   template <class T>
   void operator () (const T&t) {}
};

int main ()
{
   My_callback c;
   A a (c);
   a.call ();
}

否则，它看起来还不错。您能否更具体地说明您希望如何清理或简化它？