用作插槽的 lambda 函数中捕获的堆栈分配变量的寿命是多少？

Question

我需要帮助了解 lambda 函数的工作方式，以防止在使用它们时发生内存泄漏。更具体地说，我想知道foo在以下情况下何时被销毁：

void MainWindow::onButtonClicked()
{
    QTimer *t(new QTimer(this));
    bool foo = false;

    t->setSingleShot(true);
    t->setInterval(1000);
    t->start();

    connect(t, &QTimer::timeout, [=](){
        delete t;
        qDebug() << foo;
    });
}

使用[&]的情况如何？

Answer 1

求值的 lambda 表达式是一个仿函数实例。函子是具有operator() 的对象。捕获的变量是该函子对象的成员。 它们的生命周期不会根据它们的类型而改变。因此，无论您捕获引用还是值，它们的生命周期都是相同的。 您的工作是确保引用有效 - 即它们引用的对象没有被破坏。

仿函数的生命周期与连接的生命周期相同。连接，因此函子，将持续到：

1. 在QObject::connect()的返回值上调用QObject::disconnect()，或者

2. QObject 的生命结束并调用其析构函数。

考虑到上述情况，局部变量按引用捕获的唯一有效用途是当局​​部变量的寿命超过连接时。一些有效的例子是：

void test1() {
  int a = 5;
  QObject b;
  QObject:connect(&b, &QObject::destroyed, [&a]{ qDebug() << a; });
  // a outlives the connection - per C++ semantics `b` is destroyed before `a` 
}

或者：

int main(int argc, char **argv) {
  QObject * focusObject = {};
  QApplication app(argc, argv);
  QObject * connect(&app, &QGuiApplication::focusObjectChanged,
                    [&](QObject * obj){ focusObject = obj; });
  //...
  return app.exec();  // focusObject outlives the connection too
}

您问题中的代码过于复杂。无需手动管理此类计时器：

void MainWindow::onButtonClicked() {
  bool foo = {};
  QTimer::singleShot(1000, this, [this, foo]{ qDebug() << foo; });
}

这里的重要部分是提供对象上下文（this）作为singleShot 的第二个参数。这确保了this 必须比函子更长寿。反之，函子会在this 被销毁之前被销毁。

假设您真的想实例化一个新的瞬态计时器，在连接到此类信号的插槽中删除信号的源对象是未定义的行为。您必须将删除推迟到事件循环：

void MainWindow::onButtonClicked()
{
  auto t = new QTimer(this);
  bool foo = {};

  t->setSingleShot(true);
  t->setInterval(1000);
  t->start();

  connect(t, &QTimer::timeout, [=](){
    qDebug() << foo;
    t->deleteLater();
  });
}

t 和 foo 都被复制到仿函数对象中。 lambda 表达式是一种符号速记 - 您可以自己显式编写它：

class $OpaqueType {
  QTimer * const t;
  bool const foo;
public:
  $OpaqueType(QTimer * t, bool foo) :
    t(t), foo(foo) {}
  void operator()() {
    qDebug() << foo;
    t->deleteLater();
  }
};

void MainWindow::onButtonClicked() {
  //...
  connect(t, &QTimer::timeout, $OpaqueType(t, foo));
}

由于 lambda 实例只是一个对象，您当然可以将它分配给一个变量，如果多个信号需要连接到同一个 lambda，您当然可以摆脱代码重复：

auto f = [&]{ /* code */ };
connect(o, &Class::signal1, this, f);
connect(p, &Class::signal2, this, f);

lambda 的类型是唯一的、不可言说的，也称为不透明的类型。你不能从字面上提到它——语言中没有这样做的机制。您只能通过decltype 参考它。这里decltype是他中的不应该被命名的人。 C++ 人只是在一个哈利波特的笑话中工作，不管他们是否有意。否则我不会被说服。

Answer 2

捕获变量的 lambda 本质上是一个未命名的数据结构，捕获的变量成为该结构的成员。该数据结构被认为是可调用的，因为它提供了一个接受指定参数的operator()。

如果变量是按值捕获的，则 lambda 成员会保存这些值。只要 lambda 确实存在这些值，就像您的情况一样，作为捕获变量的副本 - 无论最初捕获的变量是否继续存在。

通过引用捕获的变量有点不同。在这种情况下，lambda 包含对变量（例如堆栈变量）的引用，如果被引用的变量不再存在，它将成为悬空引用。类似地，如果捕获的值是一个指针，并且它指向的内容不复存在。在这些情况下，使用捕获的引用或取消引用指针会产生未定义的行为。