2

我正在尝试创建一个通用的“回调”对象，它将保存任意数据并调用相关类的成员函数。由于内部政策，我不能使用 Boost。

回调对象如下所示：

template<typename Object, typename Data>
class Callback
{
public:
  typedef void (Object::*PHandler)(Callback*);
  Callback(Object* obj, PHandler handler) : pObj(obj), pHandler(handler) {}
  Callback& set(PHandler handler) { pHandler = handler; return *this; }
  void run() { (pObj->*pHandler)(this); }

public:
  Data data;

protected:
  Object* pObj;
  PHandler pHandler;
};

它适用的课程：

struct Object1
{
  struct Data { int i; };

  typedef Callback<Object1, Data> Callback1;

  void callback(Callback1* pDisp) { printf("%cb\n", pDisp->data.i); }

  void test()
  {
    Callback1 cb(this, &Object1::callback);
    cb.data.i = 1;
    cb.run();
  }
};

以下测试按预期工作：

Object1 obj1;
obj1.test();

到现在为止还挺好。

但是，当同事尝试从Callback类派生而不是使用 atypedef时，由于指针不兼容，他们得到了编译错误：

struct Object2
{
  struct Data { int i; Data(int j) { i = j; } };

  class Callback2 : public Callback<Object2, Data>
  {
    Callback2(Object2* obj, PHandler handler, int i) : Callback(obj, handler) { data.i = i; }
  };

  void callback(Callback2* pDisp) { printf("%cb\n", pDisp->data.i); }

  void test()
  {
    Callback2 cb(this, &Object2::callback, 2);
    cb.run();
  }
};

我尝试在回调类中使用“奇怪的重复模板模式”并设法让派生类工作，但它破坏了使用该typedef方法的代码。

我的问题是：

如何修改 Callback 该类以处理这两种情况，而不需要该类用户的额外工作？

4

3 回答 3

1

不幸的是，您为一家提倡重新发明轮子和使用青铜时代 C++ 的公司工作。但是，鉴于您发布的情况和代码，有一个相当简单的解决方案，无需进行太多更改。我之前不得不做类似的事情，不是因为公司政策，而是因为我们正在开发软件开发工具包，我们不想要求 SDK 的用户安装特定版本的 boost。

顺便说一句，我相信你真正追求的是信号和槽机制：如果你想让这个设计更符合成熟的解决方案，我建议研究它。

我做了一些自由假设：第一个假设是 Data 不必存储在回调中，而是可以由发送者传递。这应该是一个更灵活的设计。它仍然非常简单——你可以更进一步（例如：可变数量的参数和自定义返回类型、信号类、延迟通知等）。

template<typename Data>
class CallbackInterface
{
public: 
    virtual ~CallbackInterface() {}
    virtual void run(const Data& data) = 0;
    virtual CallbackInterface* clone() const = 0;
};

template<typename Object, typename Data>
class CallbackMethod: public CallbackInterface<Data>
{
public:
    typedef void (Object::*PHandler)(const Data&);
    CallbackMethod(Object* obj, PHandler handler) : pObj(obj), pHandler(handler) {}
    virtual void run(const Data& data) { (pObj->*pHandler)(data); }
    virtual CallbackInterface* clone() const {return new CallbackMethod(*this); }

protected:
    Object* pObj;
    PHandler pHandler;
};

template <class Data>
class Callback
{
public:
    template <class Object>
    Callback(Object* obj, void (Object::*method)(const Data&) ):
        cb(new CallbackMethod<Object, Data>(obj, method)) 
    {
    }

    Callback(const Callback& other): cb(other.cb->clone() )
    {

    }

    Callback& operator=(const Callback& other) 
    {
        delete cb;
        cb = other.cb->clone();
        return *this;
    }

    ~Callback() 
    {
        delete cb; 
    }

    void operator()(const Data& data) const
    {
       cb->run(data);
    }

private:
    CallbackInterface<Data>* cb;
};

示例用法：

struct Foo
{
    void f(const int& x)
    {
        cout << "Foo: " << x << endl;
    }
};

struct Bar
{
    void f(const int& x)
    {
        cout << "Bar: " << x << endl;
    }
};

int main()
{
    Foo f;
    Callback<int> cb(&f, &Foo::f);
    cb(123); // outputs Foo: 123

    Bar b;
    cb = Callback<int>(&b, &Bar::f);
    cb(456); // outputs Bar: 456
}

如您所见，Callback 对象本身不需要将对象类型作为模板参数传入，从而允许它指向任何类型的方法，只要该方法符合签名： void some_class::some_method(const数据＆）。将这些回调对象的列表存储在一个能够调用所有这些对象的类中，并且您拥有一个带有连接插槽的信号。

于 2010-06-24T22:46:13.500 回答
0

您必须传递派生的类类型。为了不破坏 typedef 方式，您可以给该参数一个默认值。像下面这样的东西应该工作

template<typename Object, typename Data, typename Derived = void>
class Callback;

namespace detail {
template<typename Object, typename Data, typename Derived>
struct derived { 
  typedef Derived derived_type;
};

template<typename Object, typename Data>
struct derived<Object, Data, void> { 
  typedef Callback<Object, Data, void> derived_type;
};
}

template<typename Object, typename Data, typename Derived>
class Callback : detail::derived<Object, Data, Derived>
{
  typedef typename 
    detail::derived<Object, Data, Derived>::derived_type
    derived_type;

  derived_type &getDerived() {
    return static_cast<derived_type&>(*this);
  }

public:
  // ... stays unchanged ...

  derived_type& set(PHandler handler) { 
    pHandler = handler; return getDerived(); 
  }
  void run() { (pObj->*pHandler)(&getDerived()); }

  // ... stays unchanged ...
};

或者，您可以为此简单地设置两个类。一种用于继承，一种用于不继承。第一个是为了继承

template<typename Object, typename Data, typename Derived>
class CallbackBase
{
  typedef Derived derived_type;

  derived_type &getDerived() {
    return static_cast<derived_type&>(*this);
  }

public:
  // ... stays unchanged ...

  derived_type& set(PHandler handler) { 
    pHandler = handler; return getDerived(); 
  }
  void run() { (pObj->*pHandler)(&getDerived()); }

  // ... stays unchanged ...
};

第二个是非继承。您可以为此使用基类

template<typename Object, typename Data>
struct Callback : CallbackBase<Object, Data, Callback<Object, Data> > {
  Callback(Object* obj, PHandler handler) : Callback::CallbackBase(obj, handler) {}
};
于 2010-06-24T16:43:47.117 回答
-2

由于内部政策，我不能使用 Boost。

辞职 ;）

但是，当同事尝试从 Callback 类派生而不是使用 typedef

射击他们。

我对你有感觉，我真的很喜欢。

于 2010-06-24T16:40:22.017 回答