Chapter 1. Introduction
Prev |  | Next

# Chapter 1. Introduction

## Motivation

There are many situations in which it is desirable to decouple code that detects an event, and the code that deals with it. This is especially common in GUI programming, where a toolkit might provide user interface elements such as clickable buttons but, being a generic toolkit, doesn't know how an individual application using that toolkit should handle the user clicking on it.

In C the callbacks are generally handled by the application calling a 'register' function and passing a pointer to a function and a `void*` argument, eg.

    void clicked(void* data);

    button* okbutton = create_button("ok");
    static char somedata[] = "This is some data I want the clicked() function to have";

    register_click_handler(okbutton, clicked, somedata);

When clicked, the toolkit will call `clicked()` with the data pointer passed to the `register_click_handler()` function.

This works in C, but is not typesafe. There is no compile-time way of ensuring that `clicked()` isn't expecting a struct of some sort instead of a `char*`.

As C++ programmers, we want type safety. We also want to be able to use things other than free-standing functions as callbacks.

libsigc++ provides the concept of a slot, which holds a reference to one of the things that can be used as a callback:

- A free-standing function as in the example

- A functor object that defines operator() (a lambda expression is such an object)

- A pointer-to-a-member-function and an instance of an object on which to invoke it (the object should inherit from `sigc::trackable`)

All of which can take different numbers and types of arguments.

To make it easier to construct these, libsigc++ provides the sigc::ptr_fun() and sigc::mem_fun() functions, for creating slots from static functions and member functions, respectively. They return a generic `signal::slot` type that can be invoked with `emit()` or `operator()`.

For the other side of the fence, libsigc++ provides `signal`s, to which the client can attach `slot`s. When the `signal` is emitted, all the connected `slot`s are called.

Prev |  | Next
libsigc++ | Home | Chapter 2. Connecting your code to signals