The QGraphicsObject class provides a base class for all graphics items that require signals, slots and properties. The class extends a QGraphicsItem with QObject's signal/slot and property mechanisms. It maps many of QGraphicsItem's basic setters and getters to properties and adds notification signals for many of them. Parents and Children. Signals and slots are loosely coupled: a class which emits a signal neither knows nor cares which slots receive the signal. Qt's signals and slots mechanism ensures that if you connect a signal to a slot, the slot will be called with the signal's parameters at the right time. Signals and slots can take any number of arguments of any type.
- Qt Signal Slot Base Classification
- Qt Signals And Slots Tutorial
- Qt Signal Slot Parameter
- Qt Signal And Slots
This is the sequel of my previous article explaining the implementation details of the signals and slots.In the Part 1, we have seenthe general principle and how it works with the old syntax.In this blog post, we will see the implementation details behind thenew function pointerbased syntax in Qt5.
New Syntax in Qt5
The new syntax looks like this:
Why the new syntax?
I already explained the advantages of the new syntax in adedicated blog entry.To summarize, the new syntax allows compile-time checking of the signals and slots. It also allowsautomatic conversion of the arguments if they do not have the same types.As a bonus, it enables the support for lambda expressions.
New overloads
There was only a few changes required to make that possible.
The main idea is to have new overloads to QObject::connect which take the pointersto functions as arguments instead of char*
There are three new static overloads of QObject::connect: (not actual code)
The first one is the one that is much closer to the old syntax: you connect a signal from the senderto a slot in a receiver object.The two other overloads are connecting a signal to a static function or a functor object withouta receiver.
They are very similar and we will only analyze the first one in this article.
Pointer to Member Functions
Before continuing my explanation, I would like to open a parenthesis totalk a bit about pointers to member functions.
Here is a simple sample code that declares a pointer to member function and calls it.
Pointers to member and pointers to member functions are usually part of the subset of C++ that is not much used and thus lesser known.
The good news is that you still do not really need to know much about them to use Qt and its new syntax. All you need to remember is to put the & before the name of the signal in your connect call. But you will not need to cope with the ::*, .* or ->* cryptic operators.
These cryptic operators allow you to declare a pointer to a member or access it.The type of such pointers includes the return type, the class which owns the member, the types of each argumentand the const-ness of the function.
You cannot really convert pointer to member functions to anything and in particular not tovoid* because they have a different sizeof.
If the function varies slightly in signature, you cannot convert from one to the other.For example, even converting from void (MyClass::*)(int) const tovoid (MyClass::*)(int) is not allowed.(You could do it with reinterpret_cast; but that would be an undefined behaviour if you callthem, according to the standard)
Pointer to member functions are not just like normal function pointers.A normal function pointer is just a normal pointer the address where thecode of that function lies.But pointer to member function need to store more information:member functions can be virtual and there is also an offset to apply to thehidden this in case of multiple inheritance.sizeof of a pointer to a member function can evenvary depending of the class.This is why we need to take special care when manipulating them.
Type Traits: QtPrivate::FunctionPointer
Let me introduce you to the QtPrivate::FunctionPointer type trait.
A trait is basically a helper class that gives meta data about a given type.Another example of trait in Qt isQTypeInfo.
What we will need to know in order to implement the new syntax is information about a function pointer.
The template struct FunctionPointer will give us informationabout T via its member.
ArgumentCount: An integer representing the number of arguments of the function.Object: Exists only for pointer to member function. It is a typedef to the class of which the function is a member.Arguments: Represents the list of argument. It is a typedef to a meta-programming list.call(T &function, QObject *receiver, void **args): A static function that will call the function, applying the given parameters.
Qt still supports C++98 compiler which means we unfortunately cannot require support for variadic templates.Therefore we had to specialize our trait function for each number of arguments.We have four kinds of specializationd: normal function pointer, pointer to member function,pointer to const member function and functors.For each kind, we need to specialize for each number of arguments. We support up to six arguments.We also made a specialization using variadic templateso we support arbitrary number of arguments if the compiler supports variadic templates.
The implementation of FunctionPointer lies inqobjectdefs_impl.h.
QObject::connect
The implementation relies on a lot of template code. I am not going to explain all of it.
Here is the code of the first new overload fromqobject.h:
You notice in the function signature that sender and receiverare not just QObject* as the documentation points out. They are pointers totypename FunctionPointer::Object instead.This uses SFINAEto make this overload only enabled for pointers to member functionsbecause the Object only exists in FunctionPointer ifthe type is a pointer to member function.
We then start with a bunch ofQ_STATIC_ASSERT.They should generate sensible compilation error messages when the user made a mistake.If the user did something wrong, it is important that he/she sees an error hereand not in the soup of template code in the _impl.h files.We want to hide the underlying implementation from the user who should not needto care about it.
That means that if you ever you see a confusing error in the implementation details,it should be considered as a bug that should be reported.
We then allocate a QSlotObject that is going to be passed to connectImpl().The QSlotObject is a wrapper around the slot that will help calling it. It alsoknows the type of the signal arguments so it can do the proper type conversion.
We use List_Left to only pass the same number as argument as the slot, which allows connectinga signal with many arguments to a slot with less arguments.
QObject::connectImpl is the private internal functionthat will perform the connection.It is similar to the original syntax, the difference is that instead of storing amethod index in the QObjectPrivate::Connection structure,we store a pointer to the QSlotObjectBase.
The reason why we pass &slot as a void** is only tobe able to compare it if the type is Qt::UniqueConnection.
We also pass the &signal as a void**.It is a pointer to the member function pointer. (Yes, a pointer to the pointer)
Signal Index
We need to make a relationship between the signal pointer and the signal index.
We use MOC for that. Yes, that means this new syntaxis still using the MOC and that there are no plans to get rid of it :-).
MOC will generate code in qt_static_metacallthat compares the parameter and returns the right index.connectImpl will call the qt_static_metacall function with thepointer to the function pointer.
Once we have the signal index, we can proceed like in the other syntax.
The QSlotObjectBase
QSlotObjectBase is the object passed to connectImplthat represents the slot.
Before showing the real code, this is what QObject::QSlotObjectBasewas in Qt5 alpha:
It is basically an interface that is meant to be re-implemented bytemplate classes implementing the call and comparison of thefunction pointers.
It is re-implemented by one of the QSlotObject, QStaticSlotObject orQFunctorSlotObject template class.
Fake Virtual Table
The problem with that is that each instantiation of those object would need to create a virtual table which contains not only pointer to virtual functionsbut also lot of information we do not need such asRTTI.That would result in lot of superfluous data and relocation in the binaries.
In order to avoid that, QSlotObjectBase was changed not to be a C++ polymorphic class.Virtual functions are emulated by hand.
The m_impl is a (normal) function pointer which performsthe three operations that were previously virtual functions. The 're-implementations'set it to their own implementation in the constructor.
Please do not go in your code and replace all your virtual functions by such ahack because you read here it was good.This is only done in this case because almost every call to connectwould generate a new different type (since the QSlotObject has template parameterswich depend on signature of the signal and the slot).
Protected, Public, or Private Signals.
Signals were protected in Qt4 and before. It was a design choice as signals should be emittedby the object when its change its state. They should not be emitted fromoutside the object and calling a signal on another object is almost always a bad idea.
However, with the new syntax, you need to be able take the addressof the signal from the point you make the connection.The compiler would only let you do that if you have access to that signal.Writing &Counter::valueChanged would generate a compiler errorif the signal was not public.
In Qt 5 we had to change signals from protected to public.This is unfortunate since this mean anyone can emit the signals.We found no way around it. We tried a trick with the emit keyword. We tried returning a special value.But nothing worked.I believe that the advantages of the new syntax overcome the problem that signals are now public.
Sometimes it is even desirable to have the signal private. This is the case for example inQAbstractItemModel, where otherwise, developers tend to emit signalfrom the derived class which is not what the API wants.There used to be a pre-processor trick that made signals privatebut it broke the new connection syntax.
A new hack has been introduced.QPrivateSignal is a dummy (empty) struct declared private in the Q_OBJECTmacro. It can be used as the last parameter of the signal. Because it is private, only the objecthas the right to construct it for calling the signal.MOC will ignore the QPrivateSignal last argument while generating signature information.See qabstractitemmodel.h for an example.
More Template Code
The rest of the code is inqobjectdefs_impl.h andqobject_impl.h.It is mostly standard dull template code.
I will not go into much more details in this article,but I will just go over few items that are worth mentioning.
Meta-Programming List
As pointed out earlier, FunctionPointer::Arguments is a listof the arguments. The code needs to operate on that list:iterate over each element, take only a part of it or select a given item.
That is why there isQtPrivate::List that can represent a list of types. Some helpers to operate on it areQtPrivate::List_Select andQtPrivate::List_Left, which give the N-th element in the list and a sub-list containingthe N first elements.
The implementation of List is different for compilers that support variadic templates and compilers that do not.
With variadic templates, it is atemplate struct List;. The list of arguments is just encapsulatedin the template parameters.
For example: the type of a list containing the arguments (int, QString, QObject*) would simply be:
Without variadic template, it is a LISP-style list: template struct List;where Tail can be either another List or void for the end of the list.
The same example as before would be:
ApplyReturnValue Trick
In the function FunctionPointer::call, the args[0] is meant to receive the return value of the slot.If the signal returns a value, it is a pointer to an object of the return type ofthe signal, else, it is 0.If the slot returns a value, we need to copy it in arg[0]. If it returns void, we do nothing.
The problem is that it is not syntaxically correct to use thereturn value of a function that returns void.Should I have duplicated the already huge amount of code duplication: once for the voidreturn type and the other for the non-void?No, thanks to the comma operator.
In C++ you can do something like that:
You could have replaced the comma by a semicolon and everything would have been fine.
Where it becomes interesting is when you call it with something that is not void:
There, the comma will actually call an operator that you even can overload.It is what we do inqobjectdefs_impl.h
ApplyReturnValue is just a wrapper around a void*. Then it can be usedin each helper. This is for example the case of a functor without arguments:
This code is inlined, so it will not cost anything at run-time.
Conclusion
This is it for this blog post. There is still a lot to talk about(I have not even mentioned QueuedConnection or thread safety yet), but I hope you found thisinterresting and that you learned here something that might help you as a programmer.
Update:The part 3 is available.
Author: Cao Qun
Original text: https://mp.weixin.qq.com/s/Mp…
Welcome to the official account of the technical team of the school network.
QT is a cross platform C + + GUI application development framework developed by QT company in 1991. It can be used to develop GUI programs as well as non GUI programs, such as console tools and servers. QT is an object-oriented framework. With special code generation extensions (called meta object compiler) and some macros, QT is easy to extend and allows real component programming. QT is a cross platform development framework, supporting windows, Linux, MacOS and other different platforms; QT has a large number of development documents and rich API, which brings great convenience to developers; QT users are more and more, and many excellent products are developed based on QT, such as WPS offic, opera browser, QT creator, etc. The core mechanism of QT is the signal and slot. Next, we analyze the implementation principle through the source code.
- signalWhen an object changes its state, the signal is emitted by the object, and the object is only responsible for sending the signal, and it does not know who is receiving the signal on the other end.
- groove: used to receive signals, and slots are just ordinary object member functions. A slot does not know if there is any signal connected to it.
- Signal to slot connection: all classes derived from QObject or its subclasses, such as QWidget, can contain signals and slots. It is managed by static method: QObject:: connect (sender, signal (signal), receiver, slot (slot)); where sender and receiver are pointers to objects, and signal() and slot() are macros for converting signals and slots.
- 1. First of all, we set up a good environment, such as installing qt5.7 (including source code) + vs2013 and corresponding plug-ins on Windows system. We mainly compile and debug through vs.
- 2. We write a simple instance, build it, and copy the PDB of qtcore in the QT installation directory to our executable file directory, as shown in the following figure:
Here is the demo code we want to analyze:
// MainWindow.h
// MainWindow.cpp
We can create a QT project named demo, write the above code and build it. Under vs, we can import the QT project into a vs project, compile and generate it. The running results are as follows:
Click the middle button to see the console print the following information:
Step 1: basic structure:
When we analyze the code, we can see that in the header files test and MainWindow classes, there are Q_ For macro like object, we can see an additional MOC under the executable folder above_ MainWindow.cpp Of course, what we can't do after we try to build the macro and the signal slot after we try to build the macro and the signal? Let's take a look at this macro:
It turns out that this macro is some static and virtual methods. But if we add it to a class and do not implement it, it will definitely report an error. Why can it run normally? It turns out that QT helps us to do a lot of things. Before the compiler compiles the QT code, QT first translates the syntax of QT's own extension. This operation is accomplished through MOC (meta object compiler), also known as 'meta object compiler'. First, the MOC will analyze the source code, including Q_ The header file of object is generated as a C + + source file. The name of this file will be the source file name followed by MOC_ After that, it is processed by the compiler together with the original file. Then we think that the CPP at the beginning of MOC must implement the methods in the macro above and the assignment of data. Next, let's look at the MOC_ MainWindow.cpp This document:
As we can see from the code above, it's for Q_ The static data in object are assigned values, and those methods are implemented. These are generated by QT's MOC compiler for us. The code is analyzed, and symbols are generated for signals and slots, as well as specific data structures. The following mainly records the reference count, size and offset of classes, signals and slots, which will be used later.
Through QT_ MOC_ After the macro literal is replaced, the following data is obtained:
Let's take a look at QT below_ meta_ data_ MainWindow array structure: content has two columns. The first column is the total number, and the second column is the index describing the beginning of the array, such as 1, 14, / / methods, indicating that there is a method. We can see that slots start from index 14.
From the top source code, we can see that signal and slot are used to correlate signals and slots. What are the functions of these two macros? Let's analyze:
analysis:
From the above, we can see that these two are actually string concatenation macros, which will splice '2' in front of the signal, such as '2clean()', and splice '1' in front of slots, such as '1onclean()'. Among them, qflaglocation mainly stores method in const char * locations [count] in flageddebugsignatures in qthreaddata; Table is used to locate the row information corresponding to the code.
After precompiling, it is as follows:
Through the introduction of some basic macros and data structures above, we know that QT has done a lot of work for us, helped us generate MOC code, provided us with some macros, so that we can develop succinctly and conveniently. Then, how does QT associate signals with slots, that is, two different examples, and how to communicate through the signaling slot mechanism? Next, let's look at the implementation principle of signal and slot correlation
Qt Signal Slot Base Classification
The second step is the correlation between signal and slot
- 1. Check the string of signal and slot first, qsignal_ Code is 1; signal_ Code is 2.
- 2. Get metadata (the same for sender and receiver).
This method is our upper MOC_ MainWindow.cpp Medium.
According to debugging, we can see QObject:: D_ PTR > metaobject is empty, so smeta is the static metaobject variable above. Dress code policy.
//First of all, we have to understand the definition of qmetaobject and qmetaobjectprivate
In QT, in order to achieve binary compatibility, a private class is generally defined. Qmetaobjectprivate is the private class of qmetaobject. Qmetaobject is responsible for some interface implementation, and qmetaobjectprivate is specifically implemented. These two classes are generally accessed by P pointer and D pointer. There is a macro:
Let's see that the static metaobject above is a variable of type qmetaobject, where qmetaobject is assigned a value:
In QT, in order to achieve binary compatibility, a private class is generally defined. Qmetaobjectprivate is the private class of qmetaobject. Qmetaobject is responsible for some interface implementation, and qmetaobjectprivate is specifically implemented. These two classes are generally accessed by P pointer and D pointer. There is a macro:
Let's see that the static metaobject above is a variable of type qmetaobject, where qmetaobject is assigned a value:
- 1) & QWidget:: staticmetaobject – > Superdata
- 2）qt_meta_stringdata_Test.data -> stringdata
- 3）qt_meta_stringdata_Test() -> data
- 4）qt_ static_ Metacall (callback function) – > static_ metacall
Among them, qmetaobject is the external structure, and the connection method inside calls or implements the connect in qmetaobjectprivate. The D member in qmetaobject is filled with the static metaobject data above, while the member in qmetaobjectprivate is filled with QT_ meta_ stringdata_ For the data in the test array, we can see that the first 14 data are filled. This is also the reason why MOC takes 14 as the cardinal number when generating methoddata. The conversion method is as follows:
- 3. Get and save the signal parameters and names. As follows, save the signal parameters and return the method name.
- 4. Calculate indexes (including base classes).
The implementation is as follows:
Where int handle = priv (M > D.Data) – > methoddata + 5i. We can analyze that, in fact, it is 14 + 5i. So why five? Because:
// signals: name, argc, parameters, tag, flags
1, 0, 24, 2, 0x06 / Public /,
// slots: name, argc, parameters, tag, flags
3, 0, 25, 2, 0x08 / Private /,
We can see that each signal or slot has five plastic representations.
- 5. Check the mask.
Qt Signals And Slots Tutorial
//Methodflags is an enumeration type. We can see that methodsignal = 0x04 and methodslot = 0x08;
// slots: name, argc, parameters, tag, flags
3, 0, 25, 2, 0x08 / Private /,
- 6. Judge the link type. The default is QT:: autoconnection.
We introduce some connection types:
- 1. Autoconnection: automatic connection: by default, the thread and bad object sent by the signal are equivalent to directconnection in one thread, and queuedconnection in different threads.
- 2. Directconnection: direct connection: it is equivalent to calling the slot function directly. However, when the signaled thread and the slot object are no longer the same thread, the slot function is executed in the issued signal.
- 3. Queuedconnection: queue connection: implemented internally through postevent. It is not called in real time, and the slot function is always executed in the thread where the slot function object is located. If the signal parameter is a reference type, a separate copy is made. Thread safe.
- 4. Blockingqueuedconnection: blocking connection: this connection method can only be used for the signaled thread and the object of the slot function. It can be used in a thread any more. It is implemented by semaphore + postevent, and is not called in real time. The slot function is always in the slot The function object is executed in the thread where the function object is located. However, the current thread will be blocked after the execution of the slot function is completed.
- 5. Uniqueconnection: prevents duplicate connections. If the current signal and slot are already connected, they are no longer connected.
Qt Signal Slot Parameter
Finally, it's where the signal and slot are related to the core:
First, we need to understand the following data structures:
The above three data structures are very important. QObject is our most familiar base class, and qobjectprivate is its private class for specific implementation. Qobjectprivate inherits from qobjectdata and is accessed by P pointer and D pointer in the form of composition in QObject. In the process of signal and slot correlation, the data structure connection is a very important data structure. The following structure is a vector of the connectionlist:
With the above data structure, we can analyze the following link process. We can see that the following is the connection of the called qmetaobjectprivate, and then the pointer wrapping with qmetaobject:: Connection:
QObjectPrivate:: get (s) method is actually getting a QObjectPrivate instance in QObjec, then calling addConnection method to add to the linked list:
The structure is as follows:
analysis:
Qt Signal And Slots
- 1. Each QObject object has a QObject connectionlistvector structure, which is a vector container. The basic units in it are data of the connectionlist type. The number of connectionlists is the same as the number of signals of the QObject object. Each connectionlist corresponds to a signal, which records all connections connected to the signal. We have seen that there are two important members in the definition of connectionlist: first and last. They are both pointers of connection type, pointing to the first and last connection connected to this signal respectively. All connections connected to this signal are organized in a one-way linked list. The nextconnectionlist member in the connection structure is used to point to the next connection in the list.
- 2. At the same time, each QObject object also has a senders member. Senders is a pointer of connection type. Senders itself is the head node of a linked list. All nodes in the list are connected to a slot on the QObject object. However, the list mentioned in the following paragraph is not the same, although they may have some common nodes.
- 3. Each connection object is in two linked lists at the same time. One is a one-way linked list organized by nextconnectionlist members of connection. The common point of each node in this single list is that they all rely on the same signal of the same QObject object. The head node of this list is the first in the connectionlist structure corresponding to the signal; the other is organized by the next and prev members of connection Bidirectional linked list. The common feature of each node in this bi-directional linked list is that their slots are on the same QObject object, and the head node of the list is the sender of the QObject object. The two linked lists will have cross (common nodes), but they have different link pointers, so they are not the same list.
- 4. In connect, a new connection object is first created. After setting the connection information, it is added to the two linked lists mentioned above. When disconnecting, it is removed from the two linked lists and then deleted. When a QObject object is destroyed, all connections in the bidirectional linked list pointed to by its sender pointer will be removed one by one!
Step 3: send signal to receive signal
- 1, we click on the button above and then call it into the onDestory slot, which is where we write the signal trigger:
- 2. The next step is the MOC_ MainWindow.cpp The code inside calls the static method activate of qmetaobject
//Then go to the real qmetaobject:: activate
Our example is autocontion mode, so the following code will be executed for callback:
We finally see that the function calls back to the MOC_ MainWindow.cpp Inside, then call the corresponding slot onClean;
Finally, after calling here, print out: 'MainWindow:: onclean'
Finally, after the call is finished, it will return to ondestory
Note: if we do the M_ Release operation of testwidget object (delete M_ Testwidget), and then to emit clean() in ondestory(); after accessing members, you must crash, so pay attention.
1、https://woboq.com/blog/how-qt…
2. Qt5.7 source code
3. The signal and slot demo implemented in C + + http://note.youdao.com/notesh…
