c++ - 当一个包含 lambda 的类型被分配时会发生什么？

Question

假设我用某种类型包装了一个函数，可能是一个 lambda 函数:

template<typename Function>
  struct my_struct
{
  Function f;

  my_struct(const Function &f) : f(f) {}
};

分配这种类型的实例时会发生什么？我的理解是 lambda 是不可变的，并且删除了赋值运算符。

然而，当我在下面的代码片段中将此类型分配给一个对象时，没有发出任何错误:

// a structure which contains a function;
// possibly a lambda function
template<typename Function>
  struct my_struct
{
  Function f;

  my_struct(const Function &f) : f(f) {}

  // XXX adding this assignment operator causes an error
  //my_struct &operator=(const my_struct &other)
  //{
  //  f = other.f;
  //  return *this;
  //}
};

template<typename Function>
my_struct<Function> make_struct(const Function &f)
{
  return my_struct<Function>(f);
}

int main()
{
  // create some lambda
  auto lambda = [](int x){return x;};

  // make a struct containing a copy of the lambda
  auto x = make_struct(lambda);

  // try to assign to the struct, which
  // presumably assigns to the enclosed lambda
  x = make_struct(lambda);

  return 0;
}

如预期的那样，添加注释掉的赋值运算符会产生错误:

$ g++-4.6 -std=c++0x test.cpp
test.cpp: In member function ‘my_struct<Function>& my_struct<Function>::operator=(const my_struct<Function>&) [with Function = main()::<lambda(int)>, my_struct<Function> = my_struct<main()::<lambda(int)> >]’:
test.cpp:34:25:   instantiated from here
test.cpp:13:5: error: use of deleted function ‘main()::<lambda(int)>& main()::<lambda(int)>::operator=(const main()::<lambda(int)>&)’
test.cpp:27:18: error: a lambda closure type has a deleted copy assignment operator

那么，是否可以使用 lambda 成员变量创建可赋值类型？想要尝试这似乎是一件合理的事情。例如，考虑将 lambda 与 boost::transform_iterator 组合。

Answer 1

你很接近。 lambda 有一个隐式复制构造函数，并且可能有一个隐式移动构造函数(取决于捕获的值)。它有一个已删除的复制赋值运算符。

换句话说，你可以构造它，但你不能分配它。如果你正在寻找一个通用函数对象，你想使用 std::function<> .它将函数模拟为一等值。

---

请注意，不可变不同于可赋值。当一个 lambda 被称为可变时，这意味着它的函数调用主体可以修改 lambda 的成员(即函数不是 const ):

int i = 0;

auto okay = [=](int x) mutable { i += x; };
auto error = [=](int x) { i += x; };

其中每一个都是可复制构造且不可分配的。