Qt Signals & Slots: How they work

2016-12-07 Programming Qt Tutorials Niclas Roßberger

The one thing that confuses the most people in the beginning is the Signal & Slot mechanism of Qt. But it’s actually not that difficult to understand. In general Signals & Slots are used to loosely connect classes. Illustrated by the keyword emit, Signals are used to broadcast a message to all connected Slots. If no Slots are connected, the message “is lost in the wild”. So a connection between Signals & Slots is like a TCP/IP connection with a few exceptions, but this metaphor will help you to get the principle. A Signal is an outgoing port and a Slot is an input only port and a Signal can be connected to multiple Slots.

For me one of the best thins is, that you don’t have to bother with synchronization with different threads. For example, you have one QObject that’s emitting the Signal and one QObject receiving the Signal via a Slot, but in a different thread. You connect them via QObject::connect(...) and the framework will deal with the synchronization for you. But there is one thing to keep in mind, if you have an object that uses implicitly sharing (like OpenCV’s cv::Mat) as parameter, you have to deal with the synchronization yourself. The standard use-case of Signals & Slots is interacting with the UI from the code while remaining responsive. This is nothing more than a specific version of “communicating between threads”. Another benefit of using them is loosely coupled objects. The QObject emitting the Signal does not know the Slot-QObject and vice versa. This way you are able to connect QObjects that are otherwise only reachable via a full stack of pointer-calls (e.g. this->objA->...->objZ->objB->recieveAQString()). Alone this can save you hours of work if someone decides to change some structure, e.g. the UI.

Right now I only mentioned Signal- & Slot-methods. But you are not limited to methods - at least on the Slots side. You can use lambda functions and function pointers here. This moves some conveniences from languages like Python or Swift to C++.

For some demonstrations I will use the following classes:

class AObject: public QObject
{
    Q_OBJECT

public:
    AObject(){

    }

signals:
    void signalSometing(QString param);

};

class BObject: public QObject
{
    Q_OBJECT
public:
    BObject(){

    }
public slots:
   void recieveAQString(QString param){
       qDebug() << "recived a QString: " << param;
   }

};

Using Connections

To connect a Signal to a Slot you can simply call QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString) or QObject::connect(a, SIGNAL(signalSometing(QString), b, SLOT(recieveAQString(QString)) if you want to use the “old” syntax. The main difference is, if you use the new syntax, you have compile-time type-checking and -converting. But one big advantage of the “old” method is that you don’t need to bother with inheritance and select the most specialized method. Lambdas can be a very efficient way of using Signals & Slots. If you just want to print the value, e.g. if the corresponding property changes, the most efficient way is to use lambdas. So by using lambdas you don’t have to blow up your classes with simple methods. But be aware, that if you manipulate any object inside the lambda you have to keep in mind, that synchronization issues (in a multithreaded environment) might occur.

You will get an idea of how to use the different methods in the following example:

auto a = new AObject;
auto b = new BObject;

QObject::connect(a, SIGNAL(signalSometing(QString)), b, SLOT(recieveAQString(QString))); // old Method
QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString); // new Method
QObject::connect(a, &AObject::signalSometing, [&](const QString& msg){ qDebug() << "a message for a lambda: " << msg;}); // lambda Method

a->signalSometing("Hello");
/* output:
recived a QString:  "Hello"
recived a QString:  "Hello"
a message for a lambda:  "Hello"
*/

As you see, recived a QString: "Hello" is printed two times. This happens because we connected the same Signals & Slots two times (using different methods). In the case, you don’t want that, you see some methods to prohibit that and other options in the next section Connection Types.

One side note: if you are using Qt::QueuedConnection and your program looks like the following example, at some point you will probably wonder, why calling the Signal will not call the Slots until app.exec() is called. The reason for this behavior is that the event queue, the Slot-call is enqueued, will start with this call (and block until program exits).

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    auto a = new AObject;
    auto b = new BObject;

    QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, Qt::QueuedConnection);

    a->signalSometing("Hello"); // Nothing happens

    return app.exec(); // 'recived a QString:  "Hello"' will be printed
}

And before we start with the next section here is a little trick to call a method of another thread inside the context of the other thread. This means, that the method will be executed by the other thread and not by the “calling” one.

int methodIndex = b->metaObject()->indexOfMethod("recieveAQString(QString)");
QMetaMethod method = b->metaObject()->method(methodIndex);
method.invoke(b, Qt::QueuedConnection, Q_ARG(QString, "Hello"));

To learn more about that here is your source of truth: https://doc.qt.io/qt-5/qmetamethod.html#invoke

Connection Types

Qt::AutoConnection

Qt::AutoConnection is the default value for any QObject::connect(...) call. If both QObjects that are about to be connected are in the same thread, a Qt::DirectConnection is used. But if one is in another thread, a Qt::QueuedConnection is used instead to ensure thread-safety. Please keep in mind, if you have both QObjects in the same thread and connected them the connection type is Qt::DirectConnection, even if you move one QObject to another thread afterwards. I generally use Qt::QueuedConnection explicitly if I know that the QObjects are in different threads.

Qt::DirectConnection

A Qt::DirectConnection is the connection with the most minimal overhead you can get with Signals & Slots. You can visualize it that way: If you call the Signal the method generated by Qt for you calls all Slots in place and then returns.

Qt::QueuedConnection

The Qt::QueuedConnection will ensure that the Slot is called in the thread of the corresponding QObject. It uses the fact, that every thread in Qt (QThread) has a Event-queue by default. So if you call the Signal of the QObject the method generated by Qt will enqueue the command to call the Slot in the Event-queue of the other QObjects thread. The Signal-method returns immediately after enqueuing the command. To ensure all parameters exist within the other threads scope, they have to be copied. The meta-object system of Qt has to know all the parameter types to be capable of that (see qRegisterMetaType).

Qt::BlockingQueuedConnection

A Qt::BlockingQueuedConnection is like a Qt::QueuedConnection but the Signal-method will block until the Slot returns. If you use this connection type on QObjects that are in the same thread you will have a deadlock. And no one likes deadlocks (at least I don’t know anyone).

Qt::UniqueConnection

Qt::UniqueConnection is not really a connection type but a modifier. If you use this flag you are not able to connect the same connection again. But if you try it QObject::connect(...) will fail and return false.

// Each Example is executed individually
// Example 1
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString)
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString)
// prints:
// true
// true

// Example 2
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, static_cast<Qt::ConnectionType>(Qt::AutoConnection | Qt::UniqueConnection));
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, static_cast<Qt::ConnectionType>(Qt::AutoConnection | Qt::UniqueConnection));
// prints:
// true
// false

// Example 3
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, static_cast<Qt::ConnectionType>(Qt::AutoConnection | Qt::UniqueConnection));
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString)
// prints:
// true
// true

// Example 4
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString);
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, static_cast<Qt::ConnectionType>(Qt::AutoConnection | Qt::UniqueConnection));
// prints:
// true
// false

// Example 5 (Different connection types)
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, static_cast<Qt::ConnectionType>(Qt::DirectConnection | Qt::UniqueConnection));
qDebug() <<QObject::connect(a, &AObject::signalSometing, b, &BObject::recieveAQString, static_cast<Qt::ConnectionType>(Qt::QueuedConnection | Qt::UniqueConnection));
// prints:
// true
// false

This is not everything you will ever need to know about Signals & Slots but with this information you can cover about 80% of all use-cases (in my opinion). If it happens, and you need the other 20% of information, I’ll give you some good links to search your specific problem on:

The Qt documentation:

https://doc.qt.io/qt-5/signalsandslots.html

Very deep understanding:

Part1: https://woboq.com/blog/how-qt-signals-slots-work.html

Part2: https://woboq.com/blog/how-qt-signals-slots-work-part2-qt5.html

Part3: https://woboq.com/blog/how-qt-signals-slots-work-part3-queuedconnection.html

Continue in this series: