匿名函数和函数对象在 c++++ 中存在陷阱，包括：1. 匿名函数捕获局部变量，导致值更改后仍使用捕获值；2. 函数对象长时间生命周期，可能造成内存泄漏；3. 函数对象交叉引用，引发循环引用。避免陷阱的最佳做法包括使用 [=]() 捕获所有局部变量、使用智能指针管理函数对象生命周期，以及避免函数对象之间的交叉引用。

C++ 匿名函数与函数对象的常见陷阱

简介

匿名函数和函数对象在 C++ 中非常有用，但它们也有一些常见陷阱需要注意。本文将介绍这些陷阱并提出避免它们的最佳做法。

立即学习“C++免费学习笔记（深入）”；

陷阱 1：匿名函数捕获局部变量

int main() {
  int x = 10;
  std::function<int()> fn = [&](){ return x; }; // 捕获 x
  x = 20;  // x 已更改
  return fn();  // 返回旧值 10
}

在上面的代码中，匿名函数 fn 捕获了局部变量 x。这意味着即使 x 的值在匿名函数外部发生变化，匿名函数仍将使用其捕获的值。这可能会导致微妙的错误。

最佳做法： 使用 [=]() 捕获所有局部变量，或者使用 const auto& 捕获局部变量的引用。

int main() {
  int x = 10;
  std::function<int()> fn = [=](){ return x; };  // 捕获所有局部变量
  x = 20;  // x 已更改
  return fn();  // 返回新值 20
}

陷阱 2：函数对象长时间生命周期

函数对象可以长时间存在，这可能会导致内存泄漏或其他问题。例如：

struct Foo {
  std::function<void()> fn;
  Foo() { fn = [](){ std::cout << "Hellon"; }; }
};

int main() {
  Foo foo;  // 函数对象在 foo 的整个生命周期内都存在
}

在上面的代码中，函数对象 fn 在 Foo 对象的整个生命周期内都存在。即使函数对象不再需要后，它仍会保存在内存中。

最佳做法： 确保函数对象只在需要时存在。一种方法是使用智能指针：

struct Foo {
  std::unique_ptr<std::function<void()>> fn;
  Foo() { fn = std::make_unique([](){ std::cout << "Hellon"; }); }
};

陷阱 3：函数对象交叉引用

函数对象之间可能存在交叉引用，这可能会导致循环引用并导致内存泄漏。例如：

struct Foo {
  std::function<void()> fn;
  Foo(std::function<void()>&& fn) : fn(fn) {}
};

struct Bar {
  std::unique_ptr<Foo> foo;
  Bar() { foo = std::make_unique<Foo>([&](){ bar->fn(); }); }
};

int main() {
  Bar bar;  // 循环引用
}

在上面的代码中，Foo 的构造函数捕获了 Bar 对象的 fn。Bar 的构造函数又创建了一个指向 Foo 的智能指针。这导致了 Foo 和 Bar 之间的循环引用，导致内存泄漏。

最佳做法： 避免函数对象之间出现交叉引用。一种方法是使用弱指针：

struct Foo {
  std::weak_ptr<Bar> bar;
  Foo(std::function<void()>&& fn) : fn(fn) {}
};

struct Bar {
  std::unique_ptr<Foo> foo;
  Bar() { foo = std::make_unique<Foo>([&](){ if (bar.lock()) bar.lock()->fn(); }); }
};