Click here to Skip to main content
15,860,861 members
Articles / Programming Languages / C++
Article

Yet Another C#-style Delegate Class in Standard C++

Rate me:
Please Sign up or sign in to vote.
4.89/5 (46 votes)
6 Jan 20062 min read 211K   1.2K   75   25
This article describes a C#-style delegate class completely written in standard C++.

Introduction

Delegates and events are definitely cool features of .NET/C# and there are already many attempts to simulate them in standard C++. The Delegate class described in this article tries to provide a complete and easy to use solution for using delegates in standard C++. Your feedback is welcome.

Design Goals

There are already several good delegate implementations on CodeProject. However, there is still no solution good enough for broad developers. For example, some implementations do not support multicast delegates (which is a must for events), some implementations do not support function objects (functors), some implementations are hard to use (syntax). So the design goals of my Deletgate class are:

  • Support all C++ callable entities, including static functions, member functions and functors.
  • Support single-cast and multicast in one Delegate class, so users don't have to implement multicast functionalities themselves.
  • Easy to understand and use.

Examples

1. Using delegates

#include "AcfDelegate.h"
using namespace Acf;

static void H() { ... }

class Foo {
public:
    void G() { ... }
};

class Foo2 {
public:
    void operator()(int n) { ... }
};

// Create delegate a which attaches to a static function
Delegate<void ()> a(&H);
assert(a == &H);

// Create delegate b which attaches
// to an instance and a member function
Foo foo;
Delegate<void ()> b(&foo, &Foo::G);
assert(b == std::make_pair(&foo, &Foo::G);

// Create delegate c from a
Delegate<void ()> c = a;
assert(c == &H);

// Create delegate d which attaches to a function object
Delegate<void (int)> d(Foo2());

// Call delegates
a();
d(100);

// Combine/remove delegates
d += &H;
d += std::make_pair(&foo, &Foo::G);
d -= std::make_pair(&foo, &Foo::G);
d -= &H;

2. Using events

class Button {
public:
    Delegate<void ()> Click;
};

Button btn;
btn.Click += &F;
btn.Click += std::make_pair(&o, &MyObj::G);
btn.Click();
btn.Click -= std::make_pair(&o, &MyObj::G);

3. Using events (advanced)

You may want more control on how event handlers are managed and fired, for example, you care about thread safety.

class Button {
private:
    Delegate<void ()> click;
    Mutex mutex;

public:
    template <class T>
    void add_Click(const T& h) {
        ScopedLock lock(this->mutex);
        this->click += h;
    }
    template <class T>
    void remove_Click(const T& h) {
        ScopedLock lock(this->mutex);
        this->click -= h;
    }

protected:
    void OnClick() { if (this->click) this->click(); }
};

btn.add_Click(&F);
btn.add_Click(std::make_pair(&o, &MyObj::G));

Delegate Class

namespace Acf {

template <class TSignature>
class Delegate; // no body

template <class R, class T1, class T2, ..., class TN>
class Delegate<R (T1, T2, ..., TN)> {
// Constructor/Destructor
public:
    Delegate();
    template <class TFunctor>
    Delegate(const TFunctor& f);
    template <class TPtr, class TFunctionPtr>
    Delegate(const TPtr& obj, const TFunctionPtr& mfp);
    Delegate(const Delegate& d);
    ~Delegate();

// Properties
public:
    bool IsEmpty() const;
    bool IsMulticast() const;

// Methods
public:
    template <class TFunctor>
    void Add(const TFunctor& f);
    template <class TPtr, class TFunctionPtr>
    void Add(const TPtr& obj, const TFunctionPtr& mfp);

    template <class TFunctor>
    bool Remove(const TFunctor& f);
    template <class TPtr, class TFunctionPtr>
    bool Remove(const TPtr& obj, const TFunctionPtr& mfp);

    void Clear();

// Operators
public:
    operator bool() const;
    bool operator!() const;

    template <class TFunctor>
    Delegate& operator=(const TFunctor& f);
    Delegate& operator=(const Delegate& d);

    template <class TFunctor>
    Delegate& operator+=(const TFunctor& f);

    template <class TFunctor>
    friend Delegate operator+(const Delegate& d, const TFunctor& f);
    template <class TFunctor>
    friend Delegate operator+(const TFunctor& f, const Delegate& d);

    template <class TFunctor>
    Delegate& operator-=(const TFunctor& f);

    template <class TFunctor>
    Delegate operator-(const TFunctor& f) const;

    template <class TFunctor>
    friend bool operator==(const Delegate& d, const TFunctor& f);
    template <class TFunctor>
    friend bool operator==(const TFunctor& f, const Delegate& d);

    template <class TFunctor>
    friend bool operator!=(const Delegate& d, const TFunctor& f);
    template <class TFunctor>
    friend bool operator!=(const TFunctor& f, const Delegate& d);

    R operator()(T1, T2, ..., TN) const;
};

} // namespace Acf

The TFunctor template parameter in the Delegate class supports static functions, member functions (via std::pair class that wraps an object pointer and a member function pointer) and functors. The TPtr template parameter for member functions support plain pointers (e.g. Foo*) and smart pointers (e.g. boost::shared_ptr<Foo>).

Notes

  • You must enable runtime type information (RTTI) in your project in order to use the Delegate class.
  • The current implementation supports up to six function parameters, which should be enough for most applications (and in general it's a bad practice to have more than six parameters).
  • There are no operators == and != for comparing delegates, because they are impossible to implement correctly for functors (see boost.function).
  • The current implementation is not optimized for performance. However, it should be OK for most applications.

History

  • 12/24/2005: changed the exception behavior when an empty delegate is called - if the delegate return type is void, then no exception will be thrown, otherwise an InvalidCallException will be thrown.
  • 8/28/2005: initial release.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


Written By
Web Developer
China China
Yingle Jia is a software engineer located in Beijing, China. He currently works at IBM CSDL (China Software Development Lab). His interests include C++/COM/C#/.NET/XML, etc. He likes coding and writing.

He is the creator of ACF (Another C++ Framework) project. See http://acfproj.sourceforge.net/.

He also has a blog at http://blogs.wwwcoder.com/yljia/

Comments and Discussions

 
QuestionA correct fix for GNU C++ compiler? Pin
Matt HK Lo13-Aug-13 1:16
Matt HK Lo13-Aug-13 1:16 
GeneralMy vote of 5 Pin
KenB228-Jun-10 4:49
KenB228-Jun-10 4:49 
Generalbrilliant Pin
f22-Aug-08 7:38
f22-Aug-08 7:38 
Generalstatuc member function [modified] Pin
delaneyj26-Feb-07 21:21
delaneyj26-Feb-07 21:21 
Generalcompile error with gcc Pin
zhangzq7128-Jun-06 21:34
zhangzq7128-Jun-06 21:34 
GeneralEmpty delegates Pin
Flavio Antonioli14-Oct-05 1:36
Flavio Antonioli14-Oct-05 1:36 
I would find it very handy if the delegate had at least an option to not throw an exception when a delegate that has never been assigned is nonetheless invoked. This would avoid having to check .IsEmpty() each time one wants to signal an event and doesn't know if anyone is subscribed. One could add a dummy subscriber to each delegate but not being able to add a default value in the delegate declaration (as is possible in C#) you would have to add it in the containing class constructor and that would complicate matters unnecessarily.
I've modified operator() for my personal use in the way listed below.
Thanks for a great library.

Flavio.

#define ALLOW_EXECUTE_EMPTY
#ifdef ALLOW_EXECUTE_EMPTY
R OnEmptyDelegate() const
{
return R();
}
#else
R OnEmptyDelegate() const
{
throw InvalidOperationException();
}
#endif
R operator()(ACF_DELEGATE_FUNCTION_PARAMS) const
{
if (this->_last == NULL)
OnEmptyDelegate();

if (this->_last->Previous != NULL)
InvokeDelegateList(this->_last->Previous ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_ARGS);
return this->_last->Invoke(ACF_DELEGATE_FUNCTION_ARGS);
}
GeneralRe: Empty delegates Pin
Yingle Jia15-Jan-06 16:26
Yingle Jia15-Jan-06 16:26 
GeneralSome Remarks Pin
Roland Pibinger5-Sep-05 10:50
Roland Pibinger5-Sep-05 10:50 
GeneralRe: Some Remarks Pin
Yingle Jia5-Sep-05 15:46
Yingle Jia5-Sep-05 15:46 
GeneralRe: Some Remarks Pin
Roland Pibinger6-Sep-05 7:41
Roland Pibinger6-Sep-05 7:41 
GeneralRe: Some Remarks Pin
Zac Howland11-Jan-06 20:51
Zac Howland11-Jan-06 20:51 
GeneralRe: Some Remarks Pin
Yingle Jia12-Jan-06 14:50
Yingle Jia12-Jan-06 14:50 
GeneralRe: Some Remarks Pin
Zac Howland12-Jan-06 19:26
Zac Howland12-Jan-06 19:26 
GeneralRe: Some Remarks Pin
Yingle Jia15-Jan-06 16:15
Yingle Jia15-Jan-06 16:15 
GeneralVariable Template Parameters Pin
armentage1-Sep-05 6:46
armentage1-Sep-05 6:46 
GeneralRe: Variable Template Parameters Pin
Yingle Jia1-Sep-05 15:19
Yingle Jia1-Sep-05 15:19 
GeneralRe: Variable Template Parameters Pin
armentage6-Sep-05 3:29
armentage6-Sep-05 3:29 
GeneralRe: Variable Template Parameters Pin
Zac Howland11-Jan-06 20:59
Zac Howland11-Jan-06 20:59 
Generalcool! Pin
Phil. Invoker28-Aug-05 23:23
Phil. Invoker28-Aug-05 23:23 
GeneralRe: cool! Pin
Hashim Saleem6-Jul-07 2:42
Hashim Saleem6-Jul-07 2:42 
GeneralBoost.Signals Pin
Uwe Keim28-Aug-05 3:03
sitebuilderUwe Keim28-Aug-05 3:03 
GeneralRe: Boost.Signals Pin
Yingle Jia28-Aug-05 3:50
Yingle Jia28-Aug-05 3:50 
GeneralRe: Boost.Signals Pin
lxwde28-Aug-05 15:35
lxwde28-Aug-05 15:35 
GeneralRe: Boost.Signals Pin
Anonymous29-Aug-05 16:20
Anonymous29-Aug-05 16:20 
GeneralRe: Boost.Signals Pin
John M. Drescher30-Aug-05 2:14
John M. Drescher30-Aug-05 2:14 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.