Replace handwritten for loop in C++ when index has to be accessed inside lambda

Question

I am trying to replace the hand written for loop in using_for_loop() by algorithm methods. no_for_loop() is the version that would replace using_for_loop(). Any clue on how to implement the lambda? In general, for a vector of vectors how to iterate the inner for loop in the lambda or a function object. It would require access to the outer loop index. If I were to use std::distance() to compute the index inside the lambda, I would need access to the the iterator. But I have only the value/object inside passed to the lambda. Is there is a way to pass the iterator to the lambda?
The motivation is to follow the suggestion made by the book Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library by Scott Meyers. One of them is Item 43: Prefer algorithm calls to hand-written loops

Note: In the real program "vec" is the inputs. I made it local and added assign_vec(10'000'000,vec); call to make it stand alone.
The goal is to remove the repeated 3-elements-array entirely(not need to keep one of them)

#include <algorithm> 
void assign_vec(const int64_t &count, std::vector<std::array<int64_t, 3>> &v)
{
  for (int i = 0; i < count;++i)
  {
    std::array<int64_t, 3 > a{i,i+1,i+2};
    v.emplace_back(a);
  }
}

int using_for_loop() {
  std::vector<std::array<int64_t, 3>> vec;
  assign_vec(10'000'000,vec);//vec is arbitrary. Not assume this hard coded case.
  std::sort(vec.begin(), vec.end(), [](const auto& a, const auto& b)
    {
      if (a[0] != b[0])
        return a[0] < b[0];

      return std::minmax(a[1], a[2]) < std::minmax(b[1], b[2]);
    });

  size_t k{};
  for (auto i = (size_t)0, n = vec.size(); i < n; )
  {
    auto j = i + (size_t)1;
    for (; j < n; ++j)
    {
      if (vec[i][0] != vec[j][0] || std::minmax(vec[i][1], vec[i][2]) != std::minmax(vec[j][1], vec[j][2]))
        break;
    }

    if (i + (size_t)1 == j)
      vec[k++] = vec[i];

    i = j;
  }
  vec.resize(k);
  return 0;
}

int no_for_loop() {
  std::vector<std::array<int64_t, 3>> vec;
  assign_vec(10'000'000, vec);
  size_t k{};
  //??std::for_each(std::begin(vec), std::end(vec), []() {});
  vec.resize(k);
  return 0;
}

Answer 1

There isn't an algorithm in std that does exactly what is needed here, so it's maybe worth writing one in an iterator style. This will still use for, but we can extract the element testing.

template <typename ForwardIt, typename Equiv>
ForwardIt remove_duplicated(ForwardIt first, ForwardIt last, Equiv equiv) {
    ForwardIt result = first;
    for (; first != last;) {
        next = std::find_if_not(first, last, equiv);
        if (std::next(first) == next) {
            *result++ = std::move(*first);
        }
        first = next;
    }
    return result;
}

void no_for_loop(std::vector<std::array<int64_t, 3>> & vec) {
  auto end = remove_duplicated(vec.begin(), vec.end(), equiv);
  vec.erase(end, vec.end());
}

I originally thought the algorithm was removing duplicate entries, but it also removes the first of the duplicates. Below is my original answer, which points out an existing algorithm that does just that.

I'm going to assume that this is meant to be applied to an arbitrary std::vector<std::array<int64_t, 3>>, and not one filled by assign_vec.

std::for_each is the wrong algorithm. You are removing adjacent elements that are equivalent, that is std::unique.

bool equiv(std::array<int64_t, 3> & lhs, std::array<int64_t, 3> & rhs) {
    return (lhs[0] == rhs[0]) && (std::minmax(lhs[1], lhs[2]) == std::minmax(lhs[1], rhs[2])); 
}

void no_for_loop(std::vector<std::array<int64_t, 3>> & vec) {
  auto end = std::unique(vec.begin(), vec.end(), equiv);
  vec.erase(end, vec.end());
}

Answer 2

You could make a poor man's enumeration helper like this for simplicity I only made this work for std::vector not all containers. :

#include <iostream>
#include <vector>
#include <string>

template<typename type_t>
struct enumerator_t
{
    enumerator_t(std::size_t i, type_t& v) :
        index{ i },
        value{ v }
    {
    }

    const std::size_t index{};
    type_t& value;
};

template<typename type_t>
struct const_enumerator_t
{
    const_enumerator_t(std::size_t i, const type_t& v) :
        index{ i },
        value{ v }
    {
    }

    const std::size_t index{};
    const type_t& value;
};

template<typename type_t>
auto enumerate(std::vector<type_t>& values)
{
    std::size_t index{ 0ul };
    std::vector<enumerator_t<type_t>> enumerator;
    enumerator.reserve(values.size());

    for (auto& value : values)
    {
        enumerator.emplace_back(index++, value);
    }

    return enumerator;
}

template<typename type_t>
auto const_enumerate(const std::vector<type_t>& values)
{
    std::size_t index{ 0ul };
    std::vector<const_enumerator_t<type_t>> enumerator;
    enumerator.reserve(values.size());

    for (auto& value : values)
    {
        enumerator.emplace_back(index++, value);
    }

    return enumerator;
}


int main()
{
    std::vector<std::string> values{ "one", "two", "three" };
    for (auto& [index, value] : enumerate(values))
    {
        std::cout << index << ": " << value << "\n";
    }

    for (const auto& [index, value] : const_enumerate(values))
    {
        std::cout << index << ": " << value << "\n";
    }

    return 0;
}