Software Development

Callbacks in C++ are one of those issues that seems to have been left behind by the C++ committee until recently. Apparently, closures are finally going to make it into the specs. But it's about three decades too late. It would have been nice to have back in the 80's, 90's and in the new millennium. Of course, I didn't use C++ in the 80's. I was using assembly (and BASIC). But that's besides the point. The other critical feature missing from C++ is having properties. Bjarne Stroustrup is dead set against them, so I doubt we'll see them anytime soon. Anyhow, this is why I use Borland C++ Builder even though it's not one of the most popular compilers out there. Borland has had both closures and properties for as long as I can remember.

Back to the topic at hand is callbacks and closures. Closures are usually found in functional languages. When imperative languages like Borland C++ Builder say they have closures, they usually mean something much simpler in that a pointer can also hold a reference to the object instance. So when you invoke the function reference, it knows what object to pass as the function's first parameter. FYI, all non-static member functions have an implicit "this" pointer as a first parameter. That is the parameter that is causing so much trouble with callbacks since we need both the function pointer and the "this" pointer to the object.

So what are the ways to use callbacks that point to methods? There are four ways that are most common. There are certainly other ways of doing this. For now, these are the simplest and quickest.

1. Hack your own closure.

I've done this when porting Borland C++ Builder code to GCC for example. What you do is build a class (or struct) that holds two pointers. One is the function pointer and the other is the object pointer. As to invoking the function, a simple way is to use variable arguments. You need at least one argument for the prototype, but that's no problem since you need to pass the object pointer. Unfortunately, this is prone to errors and you'll have issues with return values.

With the advent of templates, you have much more flexibility and could come up with a solution. In fact, the next two solutions are pre-built versions of this.

2. Use Boost

I don't use Boost, but a lot of people like it. I'll just repeat an example posted by Sc4Freak in this reddit thread.

using namespace boost;

function<int (int)> callback(bind(&TestClass::Foo, &TestObject, _1));

//Call TestObject.Foo(5).
callback(5);

//Change callback to a free function.
callback = SomeRandomFunction;

//Call SomeRandomFunction(8).
callback(8);

You need specific functionality for callbacks to work.

• Creation
• Assignment of method
• Assignment of function
• Invocation

Creation is done by using a template. You specify the return type and the argument types within the angle brackets. Then you use bind to have the object and its method together. Not sure about the _1. Might be the number of arguments.

Invocation is straightforward as is assignment of a function. I haven't seen assignment of a method though. Perhaps it works the same way, but use bind again, like this.

callback = bind(&TestClass::Foo, &TestObject, _1);

callback(5);

Can someone verify?


3. Use a library such as PlusCallback

I really like this one. It's simply a header file that you include. I may actually use it if I port Project V to other compilers.

Here is the link to the examples.

From the example, suppose we have the following code.

#include <callback.hpp>

struct Dog
{
    void Bark(int volume);
};
 
struct Cat
{
    void Meow(int volume);
};
 
Dog spot, rover; //We have two dogs
Cat felix; //and one cat.
 
//Define a normal function.
void Func(int a);

Creation

//Define a callback to a function returning void and taking
//one int parameter.
cb::Callback1<void, int> speak;

Assignment of method

//Point this callback at spot's Bark method.
speak.Reset(&spot, &Dog::Bark);

Assignment of function

//Callbacks can be set to free functions.
speak = Func;

Invocation

speak(50);

It also supports creation of closure instances with cb::Make1(&felix, &Cat::Meow). The examples show this used within STL containers. I'm not sure how it knows what the argument types are though. Maybe there's some template magic going on since the insert function would require a specific type.

4. Use Borland C++ Builder

This is my favourite option for my own projects because C++ Builder has closures built-in. But when at work or on other projects, you may already be using another compiler. So while this option isn't always possible, it's great when it is.

Creating a closure.

// It's a regular typedef.
// Only difference is you add the keyword __closure
typedef bool (__closure __fastcall *NCompareValue)(NEntry *A, NEntry *B);

NCompareValue myfunc;

This is code from my type system in Project V (only the typedef). You can add custom functions for comparing values of specific types in the NEntry's. What's fantastic about this is that there is no new syntax. The __closure keyword just says to also store object instance.

Assignment of method.

class NTypeModule
{
protected:
  // A built in value comparison.
  bool __fastcall DefaultNCompareValues(NEntry *A, NEntry *B);
};

NTypeModule mymodule;

// This is how you assign a closure.
myfunc = mymodule->DefaultNCompareValues;

Assignment of function.

You cannot do this. A closure is a pointer to a method only in Borland. This isn't really a big deal since you can always write a method to call the static function.

(edit: There is actually an undocumented way to do this, but I can't remember the details. I have used it. From what I recall, there is a function that will create a closure from a static function pointer and you can then use that.)

Invocation

if (myfunc(node1,node2))
{
  // Do stuff here...
}

That's it. There is ZERO new syntax. The only difference is using the __closure keyword when defining the typedef. There is ZERO change anywhere else. Closures are used everywhere in VCL for events (VCL is a C++ library for Windows GUI and structures). It's great being able to use C++ for event handlers and then simply assigning those methods to the proper event. No need for checking what event was triggered with switch statements or any need to use message maps.

But hey, it seems like a pointer that can also hold the object instance in standard C++ has been too much to ask for in these past three decades.

Obviously, the need is there. Of all the things that OOP is supposed to be about, specifically message passing, the simplest of closures should have been available from the beginning. Hopefully, the next revision of C++ will have closures. Unfortunately, it's a little late to the game. Now, if properties could eventually make it in there... well, by that time, Toronto will have won the Stanley Cup.