**Course Title:** Qt 6 Application Development with C++ **Section Title:** Multithreading and Asynchronous Operations **Topic:** Asynchronous programming using signals and slots **Introduction** In Qt, signals and slots provide a convenient and safe way to perform asynchronous programming. Signals are used to notify slots of specific events, allowing for loose coupling between objects. This technique allows us to write more responsive, efficient, and maintainable code. In this topic, we'll explore how to use signals and slots for asynchronous programming in Qt. **Key Concepts** Before we dive into the examples, let's review the key concepts: 1. **Signals**: A signal is an event notification emitted by a QObjects when a specific condition occurs. 2. **Slots**: A slot is a method that can be connected to a signal to receive notifications. 3. **Connection Type**: When connecting signals to slots, we can use different types of connections: * **AutoConnection**: QT tries to determine the connection type automatically. * **DirectConnection**: Always sends the event as a direct call. * **QueuedConnection**: Queues the event to be sent when the receiving object's thread is able to process it. * **BlockingQueuedConnection**: Queues the event and returns once the receiving object's thread has finished processing it. 4. **Meta-Object Compiler (MOC)**: Qt's MOC tool parses source code headers to generate code required for signals and slots. **Example 1: Basic Signal-Slot Connection** ```cpp // myobject.h #ifndef MYOBJECT_H #define MYOBJECT_H #include <QObject> class MyObject : public QObject { Q_OBJECT public: MyObject(QObject *parent = nullptr); void doSomething(); signals: void mySignal(const QString& message); public slots: void onMySignal(const QString& message); }; #endif // MYOBJECT_H ``` ```cpp // myobject.cpp #include "myobject.h" #include <QDebug> MyObject::MyObject(QObject *parent) : QObject(parent) { connect(this, &MyObject::mySignal, this, &MyObject::onMySignal); } void MyObject::doSomething() { emit mySignal("Hello, World!"); } void MyObject::onMySignal(const QString& message) { qDebug() << "Received signal:" << message; } ``` In the above example, we have a `MyObject` class with a signal `mySignal` and a slot `onMySignal`. We connect the signal to the slot using the `connect` method. When we emit `mySignal` in the `doSomething` method, the slot `onMySignal` receives the notification. **Example 2: Asynchronous Operation** ```cpp // worker.h #ifndef WORKER_H #define WORKER_H #include <QObject> #include <QRunnable> #include <QThread> class Worker : public QObject, public QRunnable { Q_OBJECT public: Worker(QObject *parent = nullptr); void run() override; signals: void resultReady(const QString& result); }; #endif // WORKER_H ``` ```cpp // worker.cpp #include "worker.h" #include <QDebug> #include <QThread> #include <QRandomGenerator> Worker::Worker(QObject *parent) : QObject(parent) { } void Worker::run() { // Simulate a time-consuming operation QThread::sleep(2); emit resultReady("Operation result"); QRandomGenerator* gen = new QRandomGenerator(); // do smthing with generator delete gen; } ``` ```cpp // main.cpp #include <QCoreApplication> #include "worker.h" #include <QThreadPool> int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); Worker worker; connect(&worker, &Worker::resultReady, [&worker](const QString& result) { qDebug() << "Received result:" << result; QCoreApplication::quit(); }); QThreadPool::globalInstance()->start(&worker); return a.exec(); } ``` In this example, we create a `Worker` class that inherits from `QObject` and implements the `QRunnable` interface. In the `run` method, we simulate a time-consuming operation and emit a signal when the operation is complete. We then use `QThreadPool` to start the `Worker` in a background thread and connect the `resultReady` signal to a slot that receives the result and quits the application. **Conclusion** In this topic, we've explored how to use signals and slots for asynchronous programming in Qt. We've seen how to connect signals to slots and how to emit signals from objects. We've also learned about the different types of connections and their implications. We applied this knowledge by writing an asynchronous operation with a worker thread. This pattern is very common when dealing with operations that take a long time: one should not freeze the UI, otherwise this will lead to bad user experience. From this topic, you have learned how to prevent the UI from freezing, an essential knowledge you must apply when creating Desktop Applications. Now that you've learned about asynchronous programming using signals and slots, leave us a comment if you need further clarification/explanation of the concepts. For further information, check official [Qt documentation for Signals and Slots](https://doc.qt.io/qt-6/signalsandslots.html). Please note: If you face issues running the code or have corrections, please contact us back.