There is a problem with the slot defined in Qt Correct

Step 1: connect(spin,signal(valuechanged(int)),slider,slot(setslidervalue(int)))).

connect(slider,signal(valuechanged(int)),spin,slot(setspinvalue(int)))

Step 2: (Supplement the slot declaration yourself).

void widget::setslidervalue(int nspinvalue)

if (slider->value() = (nspinvalue+100))

slider->setvalue(nspinvalue+100);

void widget::setspinvalue(int nslidervalue)

if (spin->value() = (nslidervalue-100))

spin->setvalue(nslidervalue-100);

You can think of the relationship between signals and slots as a matter of function calls. When a signal is sent out somewhere in your program, for example.

emit valuechanged(100), then it is equivalent to the slot you want to call connected to this signal, that is, the previous sentence can be understood as a call.

setnum（100）。

Of course, signals and slots are more advanced than the above calls, e.g. the setnum(100) function can be called after the execution of a function containing emit valuechanged(100) has been completed. You can also call setnum(100) where emit valuechanged(100) is executed, and then proceed to the next sentence after setnum(100) is executed. As "ianynchen" puts it, it's equivalent to a function pointer.

Since it is equivalent to a function call, the type and order of parameters of the signal and the slot should be the same. Of course, if the number of parameters of the signal is greater than the number of parameters associated with the slot, more of these parameters cannot be passed into the slot, so it is ignored.

Modular programming can be facilitated by the use of signals and slot mechanisms, which means that when writing a module, you don't care who receives the signal and what it will do after receiving it, and you don't care who sends the signal and how it is sent. You can try to have one module call another module's functions without signaling and slotting, and you will find that you need to know the structure of both modules before you can proceed.

At the same time, signals and slots can be dynamically linked and unconnected, which is very flexible.

Signals and slots are a very important part of Qt, and it is recommended that you spend more time learning them, and the flexible use of signals and slots can greatly simplify your programming work. It is recommended that you take a good look at the section of the help documentation on signals and slots.

The implementation of signals and slots is actually QT translating your source ** into a standard cpp source file containing MOC, and then compiling the connection. If you have time, you can compare your source** with the translated source containing MOC**.

Both the return type of signal and slot are void, so you can think of it as requiring the number of input parameters, type, and return type to be the same. Connect accepts char*, so in fact, signal and slot convert the following parameters to char*. To put it bluntly, you can understand signal and slot as function pointers, but because they are pointers to object functions, you must first give object pointers, and then functions.

The signal slot mechanism is actually nothing more than calling the corresponding slot function from the signal function. Therefore, the signatures of signal and slot must be consistent. Otherwise, it would be too complicated to set the corresponding way of the parameters.

You can think of signals and slots as extended macros. The purpose of this macro is to make a markup, which can only connect signal to signal or slot, and cannot be connected to any function. In this regard, Qt is not as flexible as Boost.