StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>It is unfortunate that you work for a company which advocates reinventing wheels and using bronze age C++. However, given the circumstances and the code you posted, there is a fairly simple solution without making too many changes. I've had to do similar things before not because of company policy but because we were developing a software development kit and we did not want to require that users of the SDK have a specific version of boost installed.</p> <p>BTW, I believe what you are really after is a signals and slots mechanism: I suggest studying it if you want to make this design a bit more conforming to well-established solutions.</p> <p>I took a few liberal assumptions: the primary one being that Data does not have to be stored in the callback and can instead be passed by the sender. This should be a more flexible design. It is still very simple - you can take this a lot further (ex: variable-number of arguments and custom return types, a signal class, deferred notifications, etc).</p> <pre><code>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; }; </code></pre> <p>Example usage:</p> <pre><code>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 } </code></pre> <p>As you can see, the Callback object itself does not require the object type to be passed in as a template argument, thereby allowing it to point to methods of any type provided that the method conforms to the signature: void some_class::some_method(const Data&). Store a list of these Callback objects in a class capable of calling all of them and you have yourself a signal with connected slots.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload