Access the previous element inside the function of for_each - c++

Question

I'm trying to implement the fibonacci sequence in C++17 using for_each
#include <list>
#include <algorithm>
using namespace std;
int main(int argc, char* argv[]) {
list<int> mylist = {1,2,3,4,5};
for_each( next(mylist.begin()), mylist.end(), [](int &n){n = n + prev(n);});
}
to access the previous element inside the function, prev doesn't work. How can I access the previous element inside the function? Thanks.

Answer 1

First, it's much simpler to use std::adjacent_difference for operations on consecutive elements.
If you really want to improve your understanding of std::for_each, then it's possible, but you will have to take responsibility for updating a shadow iterator yourself, as it's not possible to work back from an element to an iterator:
#include <algorithm>
#include <iostream>
#include <list>
int main()
{
std::list<int> v(15);
v.front() = 1;
auto it = v.begin();
auto prev = it;
auto current = *it++;
std::for_each(it, v.end(),
[&current,&prev](int& n){ std::swap(n, current); current = n+*prev++;});
for (auto n: v) {
std::cout << n << '\n';
}
}
However, if we use std::vector for our storage, then we do have a way to access the previous element, since vectors store their elements contiguously:
#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v(15);
v[0] = v[1] = 1;
std::for_each(v.begin()+2, v.end(),
[](int& n){ n = (&n)[-1] + (&n)[-2];});
for (auto n: v) {
std::cout << n << '\n';
}
}

Answer 2

Even if you could use prev to access the previous element, it's unclear how the posted algorithm would generate the expected result (a Fibonacci sequence), because the passed list is initialized as
list<int> mylist = {1, 2, 3, 4, 5};
The lambda would have added (if it worked) the value of the previous element (already modified!) to the current one, resulting in the sequence: 1, 2 + 1 = 3, 3 + 3 = 6, ...
It may be easier to use a stateful lambda and a different algorithm, like std::generate (or std::generate_n).
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <list>
#include <utility>
template <class T>
auto make_fibonacci_generator(T first, T second)
{
return [prev = first, cur = second] () mutable {
return cur += std::exchange(prev, cur);
};
}
template <class OutIt, class T = typename OutIt::value_type>
auto gen_n_fibonacci_numbers(T first, T second, std::size_t n, OutIt dest)
{
if ( n == std::size_t(0) )
return dest;
*dest++ = first;
if ( n == std::size_t(1) )
return dest;
*dest++ = second;
if ( n == std::size_t(2) )
return dest;
return std::generate_n(dest, n - 2, make_fibonacci_generator(first, second));
}
template <class OutIt, class T = typename OutIt::value_type>
void gen_fibonacci_numbers(T first, T second, OutIt dest, OutIt dest_last)
{
if ( dest == dest_last )
return;
*dest++ = first;
if ( dest == dest_last )
return;
*dest++ = second;
if ( dest == dest_last )
return;
std::generate(dest, dest_last, make_fibonacci_generator(first, second));
}
int main()
{
std::list<unsigned int> numbers;
gen_n_fibonacci_numbers(0, 1, 20, std::back_inserter(numbers));
for (auto i : numbers)
std::cout << ' ' << i;
std::cout << '\n';
std::array<int, 10> nums;
gen_fibonacci_numbers(0, 1, nums.begin(), nums.end());
for (auto i : nums)
std::cout << ' ' << i;
std::cout << '\n';
}
Testable here.