I'm having trouble getting to grips with the new signal/slot syntax (using pointer to member function) in Qt 5, as described in New Signal Slot Syntax. I tried changing this:
QObject::connect(spinBox, SIGNAL(valueChanged(int)),
slider, SLOT(setValue(int));
to this:
QObject::connect(spinBox, &QSpinBox::valueChanged,
slider, &QSlider::setValue);
but I get an error when I try to compile it:
error: no matching function for call to QObject::connect(QSpinBox*&,
I've tried with clang and gcc on Linux, both with -std=c++11
.
What am I doing wrong, and how can I fix it?
The problem here is that there are two signals with that name: QSpinBox::valueChanged(int)
and QSpinBox::valueChanged(QString)
. From Qt 5.7, there are helper functions provided to select the desired overload, so you can write
connect(spinbox, qOverload<int>(&QSpinBox::valueChanged),
slider, &QSlider::setValue);
For Qt 5.6 and earlier, you need to tell Qt which one you want to pick, by casting it to the right type:
connect(spinbox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
slider, &QSlider::setValue);
I know, it's ugly. But there's no way around this. Today's lesson is: do not overload your signals and slots!
Addendum: what's really annoying about the cast is that
one repeats the class name twice one has to specify the return value even if it's usually void (for signals).
So I've found myself sometimes using this C++11 snippet:
template<typename... Args> struct SELECT {
template<typename C, typename R>
static constexpr auto OVERLOAD_OF( R (C::*pmf)(Args...) ) -> decltype(pmf) {
return pmf;
}
};
Usage:
connect(spinbox, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged), ...)
I personally find it not really useful. I expect this problem to go away by itself when Creator (or your IDE) will automatically insert the right cast when autocompleting the operation of taking the PMF. But in the meanwhile...
Note: the PMF-based connect syntax does not require C++11!
Addendum 2: in Qt 5.7 helper functions were added to mitigate this, modelled after my workaround above. The main helper is qOverload
(you've also got qConstOverload
and qNonConstOverload
).
Usage example (from the docs):
struct Foo {
void overloadedFunction();
void overloadedFunction(int, QString);
};
// requires C++14
qOverload<>(&Foo:overloadedFunction)
qOverload<int, QString>(&Foo:overloadedFunction)
// same, with C++11
QOverload<>::of(&Foo:overloadedFunction)
QOverload<int, QString>::of(&Foo:overloadedFunction)
Addendum 3: if you look at the documentation of any overloaded signal, now the solution to the overloading problem is clearly stated in the docs themselves. For instance, https://doc.qt.io/qt-5/qspinbox.html#valueChanged-1 says
Note: Signal valueChanged is overloaded in this class. To connect to this signal by using the function pointer syntax, Qt provides a convenient helper for obtaining the function pointer as shown in this example: connect(spinBox, QOverload
The error message is:
error: no matching function for call to QObject::connect(QSpinBox*&,
The important part of this is the mention of "unresolved overloaded function type". The compiler doesn't know whether you mean QSpinBox::valueChanged(int)
or QSpinBox::valueChanged(QString)
.
There are a handful of ways to resolve the overload:
Provide a suitable template parameter to connect() QObject::connect
Use a temporary variable of the correct type void(QSpinBox::*signal)(int) = &QSpinBox::valueChanged; QObject::connect(spinBox, signal, slider, &QSlider::setValue); The assignment to signal will select the desired overload, and now it can be substituted successfully into the template. This works equally well with the 'slot' argument, and I find it less cumbersome in that case.
Use a conversion We can avoid static_cast here, as it's simply a coercion rather than removal of the language's protections. I use something like: // Also useful for making the second and
// third arguments of ?: operator agree.
template
Actually, you can just wrap your slot with lambda and this:
connect(spinbox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
slider, &QSlider::setValue);
will be look better. :\
The solutions above work, but I solved this in a slightly different way, using a macro, So just in case here it is:
#define CONNECTCAST(OBJECT,TYPE,FUNC) static_cast<void(OBJECT::*)(TYPE)>(&OBJECT::FUNC)
Add this in your code.
Then, your example:
QObject::connect(spinBox, &QSpinBox::valueChanged,
slider, &QSlider::setValue);
Becomes:
QObject::connect(spinBox, CONNECTCAST(QSpinBox, double, valueChanged),
slider, &QSlider::setValue);
#define CONNECTCAST(class,fun,args) static_cast<void(class::*)args>(&class::fun)
- used as CONNECTCAST(QSpinBox, valueChanged, (double))
in this case.
Success story sharing
static_cast
ugliness over the old syntax, simply because the new syntax enables a compile-time check for the existence of the signal/slot where the old syntax would fail at runtime.QSerialPort
)