如何迭代通过引用传递的多个对象？

如何解决如何迭代通过引用传递的多个对象？

假设我们有这个函数，其中 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 做同样的事情？

解决方法

一种解决方案是编写一个“做某事”的小 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    
   }
}

,

使用 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;
}

没有深拷贝。

,

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

1. 迭代 std::initializer_list 个指针或 std::reference_wrapper 个。

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

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

4. 将单向量版本写成一个独立的函数。调用两次。

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

6. 将每个 vector 包裹在一个 std::span 中，然后制作一个由两个跨度组成的 std::initializer_list，然后进城。

7. 编写一个引用数组类，将两个向量包裹在其中，然后去镇上。

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