Click here to Skip to main content
12,897,457 members (48,745 online)
Click here to Skip to main content
Add your own
alternative version


168 bookmarked
Posted 17 Jul 2005

The Impossibly Fast C++ Delegates

, 17 Jul 2005 MIT
Rate this:
Please Sign up or sign in to vote.
A implementation of a delegate library which can work faster than "the Fastest Possible C++ Delegates" and is completely compatible with the C++ Standard.


It is an answer to the article "Member Function Pointers and the Fastest Possible C++ Delegates by Don Clugston". Don proposed an approach to delegates (further called FastDelegate) which requires the same invocation code as is produced for invocation by a pointer to member function in the simplest case (he described why some compilers produce more complex code for polymorphic classes and classes with virtual inheritance). He described why many other popular approaches are inefficient. Unfortunately his approach is based on 'a horrible hack' (as he said). It works on many popular compilers, but is incompatible with the C++ Standard.

It seems to be true that the FastDelegate is the fastest possible way. But I suppose that such a claim needs a proof because modern C++ optimizing compilers make incredible things. I believe that boost::function and other dynamic memory allocation based delegates are slow, but who said there are no other good approaches?

I'm going to propose another approach, which:

  1. is fast,
  2. doesn't use dynamic allocated memory,
  3. is completely compatible with the C++ Standard.

Yet another approach to delegates

Let's consider a delegate which receives one argument and returns no value. It may be defined in the following way using the preferred syntax (as the boost::function and the FastDelegate, my library supports preferred and compatibility syntaxes; see documentation for details):

delegate<void (int)>

I've simplified its code to help you understand how it works. The following code has been derived by removing unnecessary lines under and above the considered code and by replacing template parameters with concrete types.

class delegate
        : object_ptr(0)
        , stub_ptr(0)

    template <class T, void (T::*TMethod)(int)>
    static delegate from_method(T* object_ptr)
        delegate d;
        d.object_ptr = object_ptr;
        d.stub_ptr = &method_stub<T, TMethod>; // #1

        return d;

    void operator()(int a1) const
        return (*stub_ptr)(object_ptr, a1);

    typedef void (*stub_type)(void* object_ptr, int);

    void* object_ptr;
    stub_type stub_ptr;

    template <class T, void (T::*TMethod)(int)>
    static void method_stub(void* object_ptr, int a1)
        T* p = static_cast<T*>(object_ptr);
        return (p->*TMethod)(a1); // #2


So, a delegate consists of an untyped pointer to data (because a delegate mustn't depend on the type of receiver) and a pointer to a function. This function receives the pointer to data as an extra parameter. It converts the data pointer to object pointer ('void*', unlike member pointers can be safely converted back to object pointers: [expr.static.cast], item 10) and calls the required member function.

When you create a nonempty delegate, you implicitly instantiate a stub function by getting its address (see line #1 above). It is possible because the C++ Standard allows using a pointer to member or a pointer to function as a template parameter ([temp.params], item 4):

SomeObject obj;
delegate d = delegate::from_member<SomeObject, 

Now 'd' is containing a pointer to stub function bound to 'someMethod' at compile time. Although a member pointer was specified, invocation at line #2 is as fast as direct method invocation (because its value is known at compile time).

As usual, the delegate may be invoked by an inline function call operator which redirects the call to the target method through the stub function:

d(10); // invocation of SomeObject::someMethod
       // for obj and passing them 10 as a parameter

Of course, it assumes an additional function call, but the overhead essentially depends on the optimizer. Actually, there may be no overhead at all.

Performance measurement

I've measured performance of the delegate invocation with various combinations of virtual/non-virtual methods, various numbers of arguments and with various types of inheritance. Also I've measured performance of delegates bound to a function and a static method. I've compared performance of FastDelegate with my approach using MS Visual C++ 7.1 and Intel C++ 8.0 compilers on a P4 Celeron processor.

In tangled cases, using a stub function may be a cause of a noticeable overhead (up to 5.5 times on MSVC and up to 2.4 times on Intel). But sometimes The Fastest Possible Delegates are slower (up to 15% on Intel and a little bit on MSVC). They are always slower on static members and on free functions. How could it be?

During disassembled code analysis, I've found an interesting fact. In the worst case, the compiler copies all parameters of the stub function and passes them into a target method. In some cases (if target method has no arguments or conversion is trivial), the optimizer reduces the stub function to a single jump instruction. And when a target method is inlinable, optimizer puts its code into the stub function. In this case there is no overhead at all.

The Fastest Possible Delegates are forced to use 'thiscall' calling convention. My delegates are free to use any calling convention (except 'thiscall') including '__fastcall'. It allows passing up to two int-size arguments through registers ('thiscall' passes only 'this' pointer through ECX).

Actually there exists a simple way to make your delegate based code extremely fast (if you really need it):

  • don't use complex objects as argument types and return values (use references instead),
  • don't use a virtual method as a target for delegates (because usually it may not be inlined),
  • put a target method implementation and delegate creation code into the same compilation unit.

You can try to use my benchmark code to measure performance on your platform and your compiler.

Copying and comparing delegates

Performance of copying constructor is not the matter for both types of delegates (in contrast to delegates based on dynamic memory allocation, such as boost::function). Nevertheless my delegates can be copied a bit faster because they tend to occupy less space.

My delegates cannot be compared. Comparison operators are not defined because a delegate doesn't contain a pointer to method. Pointer to a stub function can be different in various compilation units. Actually this feature cut was the main reason why Don Clugston was not satisfied with my approach.

However, I suppose that a possibility of comparing pointer-to-methods is dangerous. It may work well until once you make some class inlinable.

I know only one reason why you may need to compare delegates. It is event syntax such as that of C#. It looks nice, but it can't be implemented without dynamic memory allocation. Moreover in C++ it may not work well in some cases. I would like to suggest another event propagation mechanism, more suitable for C++ in my opinion.


Although this approach is compatible with the C++ Standard, unfortunately it doesn't work on some compilers. I haven't managed to compile a test code on Borland C++. The preferred syntax doesn't work on MSVC 7.1 although it successfully compiles boost::function in the same syntax.

I think it is because of the rarely used language features.

Event library

I'm proposing an event library to demonstrate that delegates don't really need comparison operations. Actually this event library isn't tight with my delegates. It can work with many kind of delegates including boost::function. Also it can work with callback interfaces (like those of Java).

My event library provides a fast method to subscribe and unsubscribe to an event producer (even during event emitting) and doesn't use dynamically allocated memory as well (it must be important to you if you are interested in fast delegates).

This library provides two entities: event_source (it is a simplified analogue of boost::signal) and event_binder (an analogue of boost::signals::scoped_connection). Usually an event producer keeps event_source and an event consumer keeps event_binder. A connection between a producer and a consumer exists while both event_source and event_binder exist.

You can't use an anonymous connection. Actually in Boost you can use it in two ways:

  1. you are absolutely sure that the event consumer exists longer than the event producer and
  2. you should use boost::signals::trackable as the base class of an event consumer (it is possible to implement the analogue in my library, but I'm not sure it is a good idea).

You could use it in C#-style multicast delegates, but there is another problem: you must maintain pairs of actions (subscription and unsubscription), but their correctness can't be checked at compile time.

For more details, see documentation.


May be some details of C++ design are not ideal, but I don't see any reason to break the C++ Standard. Moreover, sometimes hacking doesn't allow optimizers to present all of their abilities.



This article, along with any associated source code and files, is licensed under The MIT License


About the Author

Sergey Ryazanov
Web Developer
Russian Federation Russian Federation
I'm MS in Math (with honor). I've been working as a software engineer in the Vessel Traffic System department since the year 2002.

I like the C++, riddle solving, travelling and sports. My daughter was born when I was participating in a rock climbing competition (4 Jul 2004). Also I took up kayaking and skydiving, but unfortunately now I have no time for it.

I have about 4 years experience in ACM ICPC (ICP contests). The best achievement is 18-th place in World Finals (2002).

You may also be interested in...

Comments and Discussions

GeneralThank you Pin
David O'Neil10-Aug-05 16:38
memberDavid O'Neil10-Aug-05 16:38 
GeneralVC6 Error Pin
Anonymous26-Jul-05 22:49
sussAnonymous26-Jul-05 22:49 
GeneralRe: VC6 Error Pin
shfnet20-Jun-11 3:30
membershfnet20-Jun-11 3:30 
GeneralOfftopic: You are a very old man ! Pin
ETA26-Jul-05 0:53
memberETA26-Jul-05 0:53 
GeneralRe: Offtopic: You are a very old man ! Pin
Sergey Ryazanov27-Jul-05 2:51
memberSergey Ryazanov27-Jul-05 2:51 
GeneralYou may be able to add more flexiblity by using template classes Pin
Michael van der Bokke22-Jul-05 0:22
sussMichael van der Bokke22-Jul-05 0:22 
GeneralRe: You may be able to add more flexiblity by using template classes Pin
Sergey Ryazanov22-Jul-05 0:55
memberSergey Ryazanov22-Jul-05 0:55 
GeneralRe: You may be able to add more flexiblity by using template classes Pin
Jay Kint26-Jul-05 7:42
memberJay Kint26-Jul-05 7:42 
GeneralRe: You may be able to add more flexiblity by using template classes Pin
Sergey Ryazanov29-Jul-05 8:10
memberSergey Ryazanov29-Jul-05 8:10 
GeneralWe have some slightly different design goals. Pin
Don Clugston18-Jul-05 15:33
memberDon Clugston18-Jul-05 15:33 
Although this approach is compatible with the C++ Standard, unfortunately it doesn't work on some compilers.

This is the paradox I mentioned in my article! I think people often confuse 'Standard' and 'Portable'. In my view, 'Standard' is desirable, but I'd chose 'Portable' over 'Standard' any day. (Note that if the Standards commitee chose to define the result of invoking a cast member function pointer, my code would become standard retrospectively! (Excluding the horrible hacks for MSVC, of course))

Note that the primary design goal for my fast delegates was to make the most common case (calling a member function of a class) blindingly fast, and with the nicest possible syntax. (The code actually started life as an emulation of Borland's __closure pointers). I have only added extra functionality if it didn't interfere with that goal. The support for static functions was viewed as secondary. I make no guarantee that it is as fast as possible (after all, if it is time critical, maybe you should be using an ordinary function pointer instead).

I know only one reason why you may need to compare delegates. It is event syntax such as that of C#. It looks nice, but it can't be implemented without dynamic memory allocation. Moreover in C++ it may not work well in some cases.

More generally, comparison operators allow delegates to be stored in STL containers. Events are the most common use of this, but other applications are possible. Note that although this will probably involve dynamic memory allocation, it might only happen once in the life of the program! (eg, if you use std::vector, with an initial size of 10, you can add and remove events for years with calling 'new' as long as the number of events stays between 0 and 10 -- this is very different to a memory allocation whenever an event is created).

Certainly you can implement event systems without comparison operators -- you just combine them with some tag which can be compared -- but they are much cleaner if you have them (you have to store the tag).

Like we said in our earlier discussion, mine has:

Speed in the member function case: 5/5
Speed in the static function case: 4/5
Portability: 5/5
Syntax: 5/5
Standard: 1/5

Your method has:
Speed in the member function case: 4/5
Speed in the static function case: 5/5
Portability: 2/5
Syntax: 3/5
Standard: 5/5

Thanks for posting the article. We both agree that dynamic memory allocation in something as simple as a delegate is unacceptable.

If you rate speed and standards compliance highly, yours is the clear winner.
If you rate speed, portability and syntax highly, but don't care about standards compliance, use my scheme.
And if you don't care about speed or syntax, but want extreme flexibility, portability, and standards compliance, chose boost::function.

It would be nice to achieve all the goals at once, wouldn't it! But I suspect it is impossible without compiler support.

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.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.170424.1 | Last Updated 18 Jul 2005
Article Copyright 2005 by Sergey Ryazanov
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid