Qt Signal And Slot Arguments Are Not Compatible Devices
Qt Signal And Slot Arguments Are Not Compatible To Be

Signals and slots were one of the distinguishing features that made Qt an exciting and innovative tool back in time. But sometimes you can teach new tricks to an old dog, and QObjects gained a new way to connect between signals and slots in Qt5, plus some extra features to connect to other functions which are not slots. Let’s review how to get the most of that feature. This assumes you are already moderately familiar with signals and slots.

It would be possible to have the slots to which the resized and moved signals are connected check the new position or size of the circle and respond accordingly, but it's more convenient and requires less knowledge of circles by the slot functions if the signal that is sent can include that information. QT编译错误:Signal and slot arguments are not compatible.原因如下：信号和插槽参数不兼容。当时把connect函数写成了这样子：connect(receiver,&QUdpSocket::readyRead,this,SLOT(processPengingDatagram));解决方法connect(receiver,&am. You can't use slots as target for callbacks or invoke a slot by name. This was certainly not a design goal of Qt signal/slots, but it makes the mechanism less powerful than C#'s delegates and creates the need for a second mechanism The connect syntax is unnecessary complicated because of the SIGNAL/SLOT macros. Arguments automatic type conversion. Not only you can now use typedef or namespaces properly, but you can also connect signals to slots that take arguments of different types if an implicit conversion is possible. In the following example, we connect a signal that has a QString as a parameter to a slot that takes a QVariant.

One simple thought about the basics

I am not going to bore you with repeating basic knowledge you already have, but I want you to look at signals and slots from a certain angle, so it will be easier to understand the design of the feature I will cover next. What’s the purpose of signals and slots? It’s a way in which “one object” makes sure that when “something happened”, then “other object” “reacts to something happened”. As simple as that. That can be expressed in pseudocode like this:

Notice that the four phrases that are into quotes in the previous paragraph are the four arguments of the function call in the pseudocode. Notice also that one typical way to write the connect statement is aligning the arguments like this, because then the first column (first and third arguments) are object instances that answer “where?” and the second column (second and fourth arguments) are functions that answer “what?”.

In C++ instead of pseudocode, and using real life objects and classes, this would look like this in Qt4 or earlier:

That could be a typical statement from a “Hello World” tutorial, where a button is created and shown, and when it’s pressed the whole window closes and the application terminates.

Now to the main point that I want you to notice here. This has a very subtle advantage over a typical mechanism used in standard C or C++ 11 like callbacks with function pointers and lambda functions wrapped in std::function, and is subtle only because is so nice we often forget about it when we have used signals and slots for a while. If the sender object is destroyed, it obviously can not emit any signal because it is a member function of its class. But for the sender to call the receiver, it needs a pointer to it, and you as a user, don’t need to worry at all about the receiver being destroyed and becoming invalid (that is done automatically by the library), so you very rarely need to call QObject::disconnect.

So signals and slots are very safe by default, and in an automatic way.

The new versus the old way to use connect

The previous example shows one way that works across old versions of Qt published so far (Qt 1 to 5). Recently a blog post about porting a tutorial application from Qt 1 to Qt 5.11 has been published, and no porting was needed at all for signals, slots, or the connections! That doesn’t mean the feature is perfect, since a new way to make connections was added, keeping all the previous functionality.

The main problem with the example above is that (as you probably knew, or guessed from being all uppercase) is that SIGNAL and SLOT are macros, and what those macros do is convert to a string the argument passed. This is a problem because any typo in what gets passed to those means that the call to connect would fail and return false. So since Qt 5.0, a new overload to QObject::connect exists, and supports passing as second and fourth arguments a function pointer to specify which member function should be called. Ported to the new syntax, the above example is:

Now any typo in the name will produce a compile time error. If you misspelled “click” with “clik” in the first example, that would only fail printing a warning in the console when that function gets called. If you did that in some dialog of an application you would have to navigate to that dialog to confirm that it worked! And it would be even more annoying if you were connecting to some error handling, and is not that easy to trigger said error. But if you did the same typo in the last example, it would be a compile time error, which is clearly much better.

This example is usually said to be using the “new syntax”, and the previous example the “old syntax”. Just remember that the old is still valid, but the new is preferred in most situations.

Since this is an exciting new feature added to a new major version, which has received some extra polishing during the minor releases, many blog posts from other members of the Qt community have been published about it (for example covering implementation details or the issues that could arise when there are arguments involved). I won’t cover those topics again, and instead I will focus on the details that in my experience would be most beneficial for people to read on.

No need to declare members as slots anymore (or almost)

Qt Signal And Slot Arguments Are Not Compatible

The new syntax allows to call not just a member function declared as slot in the header with public slots: (or with protected or private instead of public), but any kind of function (more on that in the next section). There is still one use case where you would want to declare functions as slots, and that is if you want to make that function usable by any feature that happens at run time. That could be QML, for example.

Connecting to anything callable

Now we can connect to any “callable”, which could be a free standing function, a lambda function or a member function of an object that doesn’t derive from QObject. That looks in code like the following:

But wait, where is that nice symmetry with 2 rows and two columns now?

When you connect to a lambda, there is a receiver object, the lambda itself, but there is no signature to specify since it’s the function call operator (the same would happen to a function object or “functor”, by the way). And when there is a free standing function there is a signature, but there is no instance, so the third and the fourth arguments of the first two calls are somewhat merged. Note that the arguments are still checked at compile time: the signal has no arguments, and the lambda has no arguments either. Both sender and receiver are in agreement.

The example using std::bind requires a bit more explanation if you are not familiar with it. In this case we have the two objects and the two function pointers, which is to be expected for what is wanted. We don’t often think about it like this, but we always need a pointer to call a member function (unless it is static). When it is not used, it is because this is implicit, and this->call() can be shortened to call(). So what std::bind does here is create a callable object that glues together the particular instance that we want with one member function. We could do the same with a lambda:

Note that std::bind is actually much more powerful, and can be very useful when the number of arguments differ. But we will leave that topic to another article.

One common use of the above pattern with std::bind is when you have a class implemented through a data pointer (private implementation or pimpl idiom). If you need a button or a timer to call a member function of the private class that is not

Qt Signal And Slot Arguments Are Not Compatible