Question

我正在使用范围视图管道，我希望对输出进行完整转换并保持管道继续运行。据我所知，我无法返回新系列的副本，因为它不会在任何地方生活。我不明白的是为什么我不能将存储保存在lambda的闭包中。

auto counter = []() {
    std::map<int, int> counts;
    return ranges::make_pipeable([=](auto &&rng) mutable -> std::map<int, int>& {
        // Do stuff that fills in the map
        return counts;
    });
};

auto steps = foo() | counter() | bar();
auto data = // stuff
ranges::for_each(data | steps, [](auto &&i) {
    std::cout << i << std::endl;
});

当我进行发布时，这可行，但是当我进行调试时会构建这个段错误。如果我将map lambda中的counter更改为静态，并将捕获更改为引用，那么这当然是有效的（但显然很丑陋）。

我真正理解的是为什么从counter返回的lambda的生命周期（以及它的伴随闭包）至少与变量steps的生命周期一样长。< / p>

Answer 1

那是因为make_pipeable以值为参数。以下是src代码中的定义：

    struct make_pipeable_fn
    {
        template<typename Fun>
        detail::pipeable_binder<Fun> operator()(Fun fun) const
        {
            return {std::move(fun)};
        }
    };

由于您通过引用返回std::map<int, int>，因此它指向已移动的对象的地址。（std::move在上面的电话中）

如果这不是很清楚，请考虑一个更简单的例子。在下面的代码中，Noisy只是一个发出调用的结构。

#include <iostream>
#include <range/v3/utility/functional.hpp>

using namespace ranges;

struct Noisy
{
   Noisy() { local_ = ++cnt_; std::cout << "Noisy() ctor " << local_ << '\n'; }
   Noisy(const Noisy&) { local_= ++cnt_; std::cout << "Noisy(Noisy&) copy ctor " << local_ << '\n'; }
   Noisy(Noisy&&) { local_ = ++cnt_; std::cout << "Move constructor " << local_ << '\n'; }
   ~Noisy() { std::cout << "~Noisy() dtor with local " << local_ << '\n'; }

   // global object counter
   static int cnt_;

   // local count idx
   int local_ = 0;
};
int Noisy::cnt_ = 0;

auto counter = []()
{
   Noisy n;
   return make_pipeable([=](auto x) { return n; });
};

int main(int argc, char *argv[])
{
   auto steps = counter();
   std::cout << "Deleting" << '\n';
   return 0;
}

上述代码的输出是：

Noisy() ctor 1
Noisy(Noisy&) copy ctor 2
Move constructor 3
Move constructor 4
~Noisy() dtor with local 3
~Noisy() dtor with local 2
~Noisy() dtor with local 1
Deleting
~Noisy() dtor with local 4

正如您所看到的，对象2（在您的情况下持有std::map<int, int>）在行打印Deleting之前被销毁。 steps是一个pipeable_binder结构，它从我们传递的lambda延伸出来并在最后被销毁。

Answer 2

所以我拿了@skgbanga的代码并重新编写它，因此它更像实际情况。这表明将步骤应用于数据会导致管道捕获的lambdas的额外副本。

#include <iostream>
#include <vector>
#include <range/v3/all.hpp>


struct Noisy {
    Noisy() { local_ = ++cnt_; std::cout << "Noisy() ctor " << local_ << '\n'; }
    Noisy(const Noisy&) { local_= ++cnt_; std::cout << "Noisy(Noisy&) copy ctor " << local_ << '\n'; }
    Noisy(Noisy&&) { local_ = ++cnt_; std::cout << "Move constructor " << local_ << '\n'; }
    ~Noisy() { std::cout << "~Noisy() dtor with local " << local_ << '\n'; }

    // global object counter
    static int cnt_;

    // local count idx
    int local_ = 0;

    // Make this a range as well. Empty is fine
    std::vector<int> range;
    auto begin() { return range.begin(); }
    auto end() { return range.end(); }
};
int Noisy::cnt_ = 0;


auto counter = []() {
    Noisy n;
    return ranges::make_pipeable([=](auto x) mutable -> Noisy& {
        std::cout << "Returning Noisy range " << n.local_ << '\n';
        return n;
    });
};


int main(int argc, char *argv[])
{
    auto steps = counter();
    std::vector<int> data{{1, 2}};
    std::cout << "Applying" << '\n';
    auto result = data | steps;
    std::cout << "Displaying" << '\n';
    ranges::for_each(result, [](auto&& v) {
        std::cout << "Local result " << v << '\n';
    });
    std::cout << "Deleting" << '\n';
    return 0;
}

输出结果为：

Noisy() ctor 1
Noisy(Noisy&) copy ctor 2
Move constructor 3
Move constructor 4
~Noisy() dtor with local 3
~Noisy() dtor with local 2
~Noisy() dtor with local 1
Applying
Noisy(Noisy&) copy ctor 5
Noisy(Noisy&) copy ctor 6
Returning Noisy range 6
~Noisy() dtor with local 6
Noisy(Noisy&) copy ctor 7
~Noisy() dtor with local 5
Displaying
Deleting
~Noisy() dtor with local 7
~Noisy() dtor with local 4

Noisy 6是返回范围的那个，因为它是用于评估管道的副本，它几乎立即被破坏。这会导致段错误。

我希望额外的副本不应该真的发生。

管道中lambda的意外生命周期

2 个答案: