Qt Slots and C++11 lambda

The simple answer is: you can't. Or, rather, you don't want (or need!) to use sender(). Simply capture and use action.

//                                Important!
//                                   vvvv
connect(action, &QAction::triggered, this, [action, this]() {
    // use action as you wish
    ...
});

The specification of this as the object context for the functor ensures that the functor will not get invoked if either the action or this (a QObject) cease to exist. Otherwise, the functor would try to reference dangling pointers.

In general, the following must hold when capturing context variables for a functor passed to connect, in order to avoid the use of dangling pointers/references:

The pointers to the source and target objects of connect can be captured by value, as above. It is guaranteed that if the functor is invoked, both ends of the connection exist.
```
connect(a, &A::foo, b, [a, b]{});
```
Scenarios where a and b are in different threads require special attention. It can not be guaranteed that once the functor is entered, some thread will not delete either object.

It is idiomatic that an object is only destructed in its thread(), or in any thread if thread() == nullptr. Since a thread's event loop invokes the functor, the null thread is never a problem for b - without a thread the functor won't be invoked. Alas, there's no guarantee about the lifetime of a in b's thread. It is thus safer to capture the necessary state of the action by value instead, so that a's lifetime is not a concern.
```
// SAFE
auto aName = a->objectName();       
connect(a, &A::foo, b, [aName, b]{ qDebug() << aName; });
// UNSAFE
connect(a, &A::foo, b, [a,b]{ qDebug() << a->objectName(); });
```
Raw pointers to other objects can be captured by value if you're absolutely sure that the lifetime of the objects they point to overlaps the lifetime of the connection.
```
static C c;
auto p = &c;
connect(..., [p]{});
```
Ditto for references to objects:
```
static D d;
connect(..., [&d]{});
```
Non-copyable objects that don't derive from QObject should be captured through their shared pointers by value.
```
std::shared_ptr<E> e { new E };
QSharedPointer<F> f { new F; }
connect(..., [e,f]{});
```
QObjects living in the same thread can be captured by a QPointer; its value must be checked prior to use in the functor.
```
QPointer<QObject> g { this->parent(); }
connect(..., [g]{ if (g) ... });
```

QObjects living in other threads must be captured by a shared pointer or a weak pointer. Their parent must be unset prior to their destruction, otherwise you'll have double deletes:

class I : public QObject {
  ...
  ~I() { setParent(nullptr); }
};

std::shared_ptr<I> i { new I };
connect(..., [i]{ ... });

std::weak_ptr<I> j { i };
connect(..., [j]{ 
  auto jp = j.lock();
  if (jp) { ... }
});

Using lambdas as slots is straightforward (for example for an event from a QSpinbox):

connect(spinboxObject, &QSpinBox::editingFinished, this, [this]() {<do something>});

But this works only if the signal is not overloaded (that means there are several signals with the same name but different arguments).

connect(spinboxObject, &QSpinBox::valueChange, this, [this]() {<do something>});

gives a compile error, because there exist two overloaded signals: valueChanged(int) and valueChanged(const QString&) So it is necessary to qualify which version should be used:

connect(spinboxObject, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, [this](int newValue){ });

A little shorter (or better readable) is the use of QOverload:

connect(spinboxObject, QOverload<int>::of(&QSpinBox::valueChanged), this, [this](int newValue) { });

Qt Slots and C++11 lambda

Tags:

C++

Qt

C++11

Related

Recent Posts