为什么init捕获可变lambda不能有可变数据成员？

Question

这个问题与前一个问题相关，在前一个问题中，我们注意到init捕获mutablelambdas与Boost的范围和迭代器transform不兼容，因为一些相当模糊且嵌套很深的typedef故障可能很难通过破解Boost来解决。射程源。

接受的答案建议将lambda存储在std:：function对象中。为了避免潜在的virtual函数调用开销，我编写了两个函数对象，可以作为潜在的解决方法。它们在下面的代码中被称为MutableLambda1和MutableLambda2

#include <iostream>
#include <iterator>
#include <vector>
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>

// this version is conforming to the Standard
// but is not compatible with boost::transformed
struct MutableLambda1
{
    int delta;     
    template<class T> auto operator()(T elem) { return elem * delta++; }
};

// Instead, this version works with boost::transformed
// but is not conforming to the Standard
struct MutableLambda2
{
    mutable int delta;
    template<class T> auto operator()(T elem) const { return elem * delta++; }
};

// simple example of an algorithm that takes a range and laziy transformes that
// using a function object that stores and modifies internal state
template<class R, class F>
auto scale(R r, F f) 
{
    return r | boost::adaptors::transformed(f);
}

int main()
{
    // real capturing mutable lambda, will not work with boost::transformed
    auto lam = [delta = 1](auto elem) mutable { return elem * delta++; };        
    auto rng = std::vector<int>{ 1, 2, 3, 4 };

    //boost::copy(scale(rng, lam), std::ostream_iterator<int>(std::cout, ","));                 /* ERROR */
    //boost::copy(scale(rng, MutableLambda1{1}), std::ostream_iterator<int>(std::cout, ","));   /* ERROR */
    boost::copy(scale(rng, MutableLambda2{1}), std::ostream_iterator<int>(std::cout, ","));     /* OK!   */
}

不使用lam和MutableLambda1编译行，并正确打印MutableLambda2行的1,4,9,16的实例。

然而，标准草案提到

5.1.2 Lambda表达式[expr.prim.lambda]

5 [...] 当且仅当lambda表达式的parameter declaration子句后面没有mutable时，此函数调用运算符或运算符模板被声明为const（9.3.1）。[...]

11对于每个初始捕获，在闭包类型中声明由初始捕获标识符命名的非静态数据成员。此成员不是一个位字段，并且不可更改。[...]

这意味着MutableLambda2不是init捕获mutablelambda表达式的一致性手写替代品。

• 为什么初始化捕获的实现是可变的lambdas（即非const函数调用操作符）？
• 为什么看似等价的可变的数据成员与const函数调用操作符的替代被禁止？
• （奖励）为什么Boost范围和迭代器转换依赖于函数对象运算符（）是const的事实？

Answer 1

正如注释中指出的，可变lambda需要一个非const函数调用操作符，以便让函数对象的const引用表示纯函数。

原来我申请的罪魁祸首是升压。迭代器underyling的升压。范围实现的提升::adaptor::转换。在Boost中进行了一些挖掘之后。迭代器文档对transform_iterator的要求，原来（粗体强调我的）

类型UnaryFunction必须是可赋值、可复制构造的，表达式f（*i）必须有效，其中f是类型UnaryFunction的常量对象，i是类型迭代器的对象，f（*i）的类型必须是

因此，不能使用lambda编写有状态的非纯函数对象，而必须使用const函数调用operator（）和表示状态的mutable数据成员来编写。这一点在本相关问题中也有提及

注意：这里有一个开放的bug报告。

Answer 2

template<class L>
struct force_const_call_t {
  mutable L f;
  template<class...Args>
  auto operator()(Args&&...args) const
  { return f(std::forward<Args>(args)...); }
};
template<class L>
force_const_call_t<L> force_const_call(L&&f){
  return {std::forward<L>(f)};
}

上面应该允许您使用lambda，将其包装在force\u const\u调用（…）中，并调用boost算法，而无需自定义可变对象可调用对象（或者更准确地说，上面将lambda转换为自定义可变对象可调用对象）。