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

【问题标题】：How to pass and then invoke generic callback functions without causing circular dependency如何在不引起循环依赖的情况下传递然后调用泛型回调函数
【发布时间】：2009-02-23 16:22:03
【问题描述】：

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

我一直在使用以下解决方案的变体，但我一直想知道是否有更好/更清洁的方法来实现它。我正在寻找非增强解决方案。不过，我们可以看看 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 ();
}

【问题讨论】：

对不起 - 我不太明白你的代码的意义。为什么不 boost::bind 和 boost::function 做你想做的事？这看起来非常复杂 - 我一定错过了一些强大的功能，它可以让你做到。
我不知道你的实际问题是什么。你能改写你想要达到的目标吗？

标签： c++ boost callback

【解决方案1】：

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

【讨论】：

请提供使用带有回调的递归以避免依赖的示例？谢谢

【解决方案2】：

如果您只是在寻找清理建议，我建议将“My_callback”设为普通类，而不是类模板。在这种情况下，它显然不需要成为模板。相反，如果 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 ();
}

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

【讨论】：

【解决方案3】：

一种方法是使用派生类：

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++ 模板来说很困难。

【讨论】：