How to iterate over several objects passed by reference?

Question

Let's say we have this function, where vec1 and vec2 store the same kind of data:

int myFunc(vector<int>& vec1, vector<int>& vec2) {
    for (auto const& elem : vec1) {
        // do something
    }
    for (auto const& elem : vec2) {
        // do the same thing
    }
}

Clearly, duplicating code is not great. However, the following is not a solution:

int myFunc(vector<int>& vec1, vector<int>& vec2) {
    for (auto const& vec : {vec1, vec2}) {
        for (auto const& elem : vec) {
            // do something
        }
    }
}

Doing so would result in a deep copy of vec1 and vec2, which is not what we want. I don't see a way to use pointers here as the vectors are passed in by reference (let's assume we can't change the function signature).

So how do we do the same thing to vec1 and vec2 without duplicating code?

Answer 1

It's fairly simple to use std::reference_wrapper to avoid making a deep copy, and pretty much do the same thing what you wanted to do originally:

#include <iostream>
#include <functional>
#include <vector>

int myFunc(std::vector<int>& vec1, std::vector<int>& vec2) {
    for (auto const& vec : {std::ref(vec1), std::ref(vec2)}) {
        auto const &real_vec=vec.get();

        for (auto const& elem : real_vec) {
        }
    }
    return 0;
}

int main()
{
    std::vector<int> vec1, vec2;

    myFunc(vec1, vec2);
    return 0;
}

No deep copies.

Answer 2

One solution would be to write a small lambda that "does something", and then you don't have to repeat that code multiple times:

int myFunc(vector<int>& vec1, vector<int>& vec2) 
{
   auto do_something = [&](auto const & elem) {
        // do something
   }
 
   for (auto const& elem : vec1) {
        do_something(elem);
   }

   for (auto const& elem : vec2) {
        do_something(elem);    
   }
}

---

If you can use the range-v3 library, you can write it like this:

int myFunc(vector<int>& vec1, vector<int>& vec2) 
{
   for (auto const& elem : ranges::views::concat(vec1, vec2)) {
        // dosomething    
   }
}