Unexpected lifetime of lambda in pipeline - c++

Question

I'm using a pipeline of ranges views and I want to do a complete transformation of the output and keep the pipeline going. I understand that I can't return a copy of the new range because it wouldn't live anywhere. What I don't understand is why I can't keep the storage in the lambda's closure.
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;
});
When I do a release build this works, but when I do a debug build this segfaults. If I change the map in the counter lambda to be static and the capture to be by reference then this works of course (but is clearly ugly as anything).
What I don't really understand is why the lifetime of the lambda returned from counter (and it's attendant closure) isn't at least as long as the lifetime of the variable steps.

Answer 1

That's because make_pipeable takes it argument by value. Here is the definition from the src code:
struct make_pipeable_fn
{
template<typename Fun>
detail::pipeable_binder<Fun> operator()(Fun fun) const
{
return {std::move(fun)};
}
};
Since you are returning std::map<int, int> by reference, it is pointing to an address of an object which has been moved from. (std::move in the above call)
If this is not super clear, consider a simpler example. In the below code, Noisy is just a struct which emits out its calls.
#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;
}
The output of the above code is this:
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
As you can see, object 2 (which in your case is holding the std::map<int, int>) is destroyed before the line printing Deleting. steps is a pipeable_binder struct which extends from our passed lambda and is destroyed at the end.

Answer 2

So I took #skgbanga's code and re-wrote it so it works more like the actual situation. This shows that the application of the steps to the data results in extra copies of the lambdas captured by the pipeline.
#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;
}
The output is:
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 is the one that returns the range and because it was a copy used in the evaluation of the pipe it is almost immediately destructed. This then causes the segfault.
I expect that the extra copies shouldn't really happen.