如何遍历通过引用传递的多个对象？

Question

假设我们有这个函数，其中 vec1 和 vec2 存储相同类型的数据：

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

显然，复制代码并不是很好。但是，以下不是解决方案：

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

这样做会导致 vec1 和 vec2 的深层副本，这不是我们想要的。我在这里看不到使用指针的方法，因为向量是通过引用传入的（假设我们不能更改函数签名）。

那么我们如何在不重复代码的情况下对 vec1 和 vec2 做同样的事情呢？

Answer 1

使用std::reference_wrapper 来避免进行深拷贝相当简单，并且几乎可以做与您最初想做的事情相同的事情：

#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;
}

没有深拷贝。

Answer 2

一种解决方案是编写一个“做某事”的小型 lambda，然后您不必多次重复该代码：

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);    
   }
}

---

如果可以使用range-v3库，可以这样写：

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

Answer 3

这里有许多不同的解决方案：

1. 遍历指针的std::initializer_list 或std::reference_wrappers。

2. 编写一个 lambda，包含循环体或整个循环。手动调用两次。

3. 写foreach_arg(lambda, args...)。使用它，传递一个循环遍历传入向量的 lambda。

4. 将单向量版本写为独立函数。调用两次。

5. 写一个可变参数版本。将循环放入 lambda 并以逗号折叠执行它。

6. 将每个vector 包装在std::span 中，然后将std::initializer_list 分成两个跨度，然后去城里。

7. 写一个 ref-array 类，把两个向量包在里面，然后去城里。

8. 使用 range-v3 延迟连接向量并迭代连接。