Shulou(Shulou.com)06/03 Report--

This article mainly introduces the connection mode of Qt signal and slot, which is very detailed and has certain reference value. Friends who are interested must read it!

Brief introduction

Signal slot is one of the proud mechanisms of Qt framework. When a user triggers an event, a signal is sent, which is aimless, similar to a broadcast. If an object is interested in the signal, it connect binds a function (called slot slot) to process the signal. That is to say, when the signal is sent, the connected slot function is automatically called back. This is somewhat similar to the observer pattern in the development pattern, that is, when an event of interest occurs, an action is automatically triggered.

Signal and slot are the unique information transmission mechanism of Qt and the important foundation of Qt design program, which can establish a kind of connection between objects that do not interfere with each other. The essence of a slot is a member function of a class, and its parameters can be of any type. Almost no different from the ordinary C++ member function, it can be a virtual function or it can be overloaded. It can be public, protected, private, or called by other C++ member functions. The only difference is that the slot can be connected to the signal and is called whenever the signal connected to the slot is transmitted.

The fifth parameter of the connect function for connecting signal slots

The prototype of the connect function is as follows:

[static] QMetaObject::Connection QObject::connect (const QObject * sender, const char * signal, const QObject * receiver, const char * method, Qt::ConnectionType type = Qt::AutoConnection)

ConnectionType is an enumeration defined in Qt namespace, as follows:

Enum ConnectionType {AutoConnection, DirectConnection, QueuedConnection, BlockingQueuedConnection, UniqueConnection = 0x80}

Qt::AutoConnection: default value. Based on the thread where the sender and receiver are located, the judgment is made when the signal is sent. Use Qt::DirectConnection connections if you are in the same thread, otherwise use Qt:: QueuedConnection connections. It should be noted that this judgment has nothing to do with the thread in which the sender object is located, but the thread that signals the action.

Qt::DirectConnection: the slot function is called directly when the signal is sent, and the slot function runs on the thread where the signal sender is located. The effect looks as if the slot function is called directly at the location where the signal is sent. It should be noted that in a multithreaded environment, it is dangerous and may cause collapse.

Qt::QueuedConnection: the slot function is called when it controls the event loop back to the receiver's thread, and the slot function runs on the signal receiver's thread. After the signal is sent, the slot function is not called immediately until the receiver's current function is executed and enters the event loop. This is commonly used in multithreaded environments.

Qt::BlockingQueuedConnection: the slot function is called at the same time as Qt::QueuedConnection, but after sending the signal, the sender's thread will block until the slot function is finished, which may be needed in situations where synchronization between multiple threads is required. It should be noted that the receiver and sender must not be on the same thread, otherwise the program will deadlock

Qt::UniqueConnection: this flag can be used in combination with the above four bitwise or (|). When this flag is set, when a signal and slot are already connected, repeated connections will fail, that is, repeated connections will be avoided.

The connection between the signal and the slot

C++ connection signal slot-Qt4 syntax

Connect (ui- > pushButton, SIGNAL (clicked ()), this, SLOT (close ()

C++ connection signal slot-Qt5 syntax

Connect (ui- > pushButton, & QPushButton::clicked, this, & MainWindow::close)

C++ connection signal slot-function pointer

Void (MainWindow:: * buttonClickSlot) () = & MainWindow::onButtonPushed;connect (ui- > pushButton, & QPushButton::clicked, this, buttonClickSlot)

C++ connection signal slot-Lambda expression

Connect (ui- > pushButton, & QPushButton::clicked, this, [=] () {this- > close ();})

The slot in which C++ signal is connected to QML.

Class Test {signals: void sendData (QString str);}

1) if you are registering a global object, you need to use a Connections connection:

Connections {target: test onSendData: {console.log (str)}}

2) if you are registering a class, you need to instantiate the object first, and then receive it directly using on:

Test {onSendData: {console.log (str)}}

The slot where the QML signal connects to the C++

# include QObject * quitButton = root- > findChild ("quitButton"); if (quitButton) {QObject::connect (quitButton, SIGNAL (clicked ()), & app, SLOT (quit ());}

C++ calls QML function

QObject * changeBtn = root- > findChild ("objectName"); if (changeBtn) {QMetaObject::invokeMethod (changeBtn, "changeColor");}

QML calls C++ function

OnClicked: {className.test ();}

The slot of the QML signal connected to the QML

/ / A.qmlRectangle {signal sendData (var data)} / / B.qmlRectangle {onSendData: console.log (data)} these are all the contents of the article "what are the connections between Qt signals and slots". Thank you for reading! Hope to share the content to help you, more related knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.