基本类型和复杂类型的通用 for 循环

Question

假设我有这两个std::vector：

std::vector<int> v_int(1000);
std::vector<T> v_T(1000); // Where T is copy-costy type

如果我需要（单独）循环浏览它们而不需要编辑我可能使用的项目：

for(const auto item:v_int){
    //...
}

for(const auto& item:v_T){ //Note &
    //...
}

使用const auto item:v_T 进行迭代太糟糕了，因为每次迭代都会执行一个副本。然而，使用const auto& item:v_int 不是最佳的，但也不是那么糟糕。因此，如果我需要一个同时处理它们的代码，我曾经使用const auto& item:v。

问题：是否有一种通用的方式来编写 for 循环，它会为它们两者使用最好的声明？比如：

template <typename T>
void iterate(const std::vector<T> v){
    for(const auto/*&*/ item:v){ // activate & if T is not elementary type
         //...
    }
}

Answer 1

您可以使用标准类型特征来做到这一点：

template <typename T>
using select_type = std::conditional_t<std::is_fundamental<T>::value,
                                      const T, const T&>;

template <typename T>
void iterate(const std::vector<T> v){
    for(select_type<T> item:v){ // activate & if T is not elementary type
         //...
    }
}

但是，我质疑这样做是否明智。它只是把代码弄乱了一些不太可能产生任何影响的东西。

Answer 2

当您不在乎时使用auto&&。当你必须保证它没有被编辑时，使用auto const&。

引用是别名，在像循环这样的直接上下文中，优化不存在是微不足道的，尤其是在从未修改过值的情况下。

将引用通过编译单元边界传递给函数时会遇到一些困难，这就是为什么有时建议按值传递 int 而不是 const& 的原因，但这并不适用于此。

Answer 3

我不是template 领域的专家，但我认为困扰您的是char 的副本将只复制一个字节，而使用& 将复制sizeof(char*) 字节。

我想到的是使用sizeof(T)。

在这种情况下，您可以使用

if (sizeof(T) >= sizeof(void*))
     // use '&'
else
     // don't use '&'

由于sizeof 在编译时被评估，这个if 分支将被编译器优化出来。

Answer 4

我个人只会对每种情况使用 const auto& 因为开销可以忽略不计，除非您需要在紧密循环中处理一些非常大的数据集。

然而，获得你想要的东西的一种方法可能是为你的迭代方法实现模板特化：

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

template <typename T>
void iterate(const std::vector<T>& v){
    for(const auto& item:v){
        std::cout << item << std::endl;
    }
}

template <>
void iterate(const std::vector<int>& v){
    for(const auto item:v){
         std::cout << "[" << item << "]" << std::endl;
    }
}

int main()
{
    std::vector<std::string> strings = { "foo", "bar" };
    std::vector<int> numbers = { 1, 2 };

    iterate(strings);
    iterate(numbers);
}

注意：您更有可能看到将向量复制到迭代函数中会降低性能:)