Chapter 4. Advanced topics

Table of Contents


Suppose you already have a function that you want to be called when a signal is emitted, but it takes the wrong argument types. For example, lets try to attach the warn_people(std::string) function to the detected signal from the first example, which didn't supply a location string.

Just trying to connect it with:


results in a compile-time error, because the types don't match. This is good! This is typesafety at work. In the C way of doing things, this would have just died at runtime after trying to print a random bit of memory as the location - ick!

We have to make up a location string, and bind it to the function, so that when signal_detected is emitted with no arguments, something adds it in before warn_people is actually called.

We could write it ourselves - it's not hard:

void warn_people_wrapper() // note this is the signature that 'signal_detected' expects
    warn_people("the carpark");

but after our first million or so we might start looking for a better way. As it happens, libsigc++ has one.

sigc::bind(slot, arg);

binds arg as the argument to slot, and returns a new slot of the same return type, but with one fewer arguments.

Now we can write:

myaliendetector.signal_detected.connect(sigc::bind( sigc::ptr_fun(warn_people), "the carpark" ) );

If the input slot has multiple args, the rightmost one is bound.

The return type can also be bound with sigc::bind_return(slot, returnvalue); though this is not so commonly useful.

So if we can attach the new warn_people() to the old detector, can we attach the old warn_people (the one that didn't take an argument) to the new detector?

Of course, we just need to hide the extra argument. This can be done with sigc::hide, eg.

myaliendetector.signal_detected.connect( sigc::hide<std::string>( sigc::ptr_fun(warn_people) ) );

The template arguments are the types to hide (from the right only - you can't hide the first argument of 3, for example, only the last).

sigc::hide_return effectively makes the return type void.