指针到成员,模板和继承混音
-
29-09-2019 - |
题
我正在尝试创建一个通用的“回调”对象,该对象将保存任意数据并调用相关类的成员功能。由于内部政策,我无法使用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
班级而不是使用 typedef
, ,由于不兼容的指针,他们遇到了汇编错误:
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
与两种情况一起工作的课程,并且不需要班级用户的额外工作?
解决方案
您必须通过派生的类型。为了不破坏Typedef-way,您可以将该参数提供一个默认值。像以下内容应该有效
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) {}
};
其他提示
不幸的是,您在一家倡导重新发明车轮和使用青铜时代C ++的公司工作。但是,鉴于您发布的情况和代码,有一个相当简单的解决方案而不会进行太多更改。我之前必须做类似的事情,不是因为公司政策,而是因为我们正在开发软件开发套件,并且我们不想要求SDK的用户安装了特定版本的Boost版本。
顺便说一句,我相信您真正追求的是信号和老虎机机制:如果您想让这种设计更符合完善的解决方案,我建议您研究它。
我采取了一些自由主义假设:主要的假设是数据不必存储在回调中,而是可以由发件人传递。这应该是一个更灵活的设计。它仍然非常简单 - 您可以将其更进一步(例如:参数和自定义返回类型的可变数字,信号类,递延通知等)。
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
}
如您所见,回调对象本身不需要将对象类型作为模板参数传递,从而允许其指向任何类型的方法,前提是该方法符合签名:void some_class :: somen_method(const(const)数据&)。将这些回调对象的列表存储在能够调用所有这些的类中,您自己有一个带有连接插槽的信号。
由于内部政策,我无法使用Boost。
辞职 ;)
但是,当同事试图从回调类派生而不是使用Typedef时
射击他们。
我为你感到,我真的做到了。