C ++中类似Python的循环枚举[重复]

Question

可能重复：
Find position of element in C++11 range-based for loop?

我有一个vector，我想对其进行迭代，同时访问每个单独元素的索引（我需​​要将元素及其索引都传递给函数）。我考虑了以下两种解决方案：

std::vector<int> v = { 10, 20, 30 };

// Solution 1
for (std::vector<int>::size_type idx = 0; idx < v.size(); ++idx)
    foo(v[idx], idx);

// Solution 2
for (auto it = v.begin(); it != v.end(); ++it)
    foo(*it, it - v.begin());

我想知道是否有更紧凑的解决方案。类似于 Python 的enumerate。这是我使用 C++11 范围循环得到的最接近的结果，但必须在私有范围内定义循环外部的索引似乎比 1 或 2 更糟糕：

{
    int idx = 0;
    for (auto& elem : v)
        foo(elem, idx++);
}

有没有什么方法（可能使用 Boost）来简化最新的示例，从而使索引自包含到循环中？

Answer 1

这是一种使用惰性求值的有趣解决方案。首先构造生成器对象enumerate_object：

template<typename Iterable>
class enumerate_object
{
    private:
        Iterable _iter;
        std::size_t _size;
        decltype(std::begin(_iter)) _begin;
        const decltype(std::end(_iter)) _end;

    public:
        enumerate_object(Iterable iter):
            _iter(iter),
            _size(0),
            _begin(std::begin(iter)),
            _end(std::end(iter))
        {}

        const enumerate_object& begin() const { return *this; }
        const enumerate_object& end()   const { return *this; }

        bool operator!=(const enumerate_object&) const
        {
            return _begin != _end;
        }

        void operator++()
        {
            ++_begin;
            ++_size;
        }

        auto operator*() const
            -> std::pair<std::size_t, decltype(*_begin)>
        {
            return { _size, *_begin };
        }
};

然后，创建一个封装函数 enumerate，它将推导出模板参数并返回生成器：

template<typename Iterable>
auto enumerate(Iterable&& iter)
    -> enumerate_object<Iterable>
{
    return { std::forward<Iterable>(iter) };
}

你现在可以这样使用你的函数了：

int main()
{
    std::vector<double> vec = { 1., 2., 3., 4., 5. };
    for (auto&& a: enumerate(vec)) {
        size_t index = std::get<0>(a);
        double& value = std::get<1>(a);

        value += index;
    }
}

上面的实现只是一个玩具：它应该适用于const 和非const 左值引用以及右值引用，但考虑到它复制整个可迭代对象多次。这个问题肯定可以通过额外的调整来解决。

从 C++17 开始，分解声明甚至允许您使用酷酷的类似 Python 的语法来直接在 for 初始化程序中命名索引和值：

int main()
{
    std::vector<double> vec = { 1., 2., 3., 4., 5. };
    for (auto&& [index, value] : enumerate(vec)) {
        value += index;
    }
}

符合 C++ 标准的编译器将 auto&& 分解为 index 并将 value 分解为 double&。

Answer 2

正如@Kos 所说，这是一件非常简单的事情，我真的认为没有必要进一步简化它，并且我个人会坚持使用带有索引的传统 for 循环，除了我会放弃 std::vector<T>::size_type 和只需使用std::size_t:

for(std::size_t i = 0; i < v.size(); ++i)
    foo(v[i], i);

我不太热衷于解决方案 2。它需要（有点隐藏）随机访问迭代器，这不允许您轻松交换容器，这是迭代器的强项之一。如果您想使用迭代器并使其通用（并且当迭代器非随机访问时可能会导致性能下降），我建议使用std::distance：

for(auto it(v.begin()); it != v.end(); ++it)
    foo(*it, std::distance(it, v.begin());

Answer 3

一种方法是将循环包装在您自己的函数中。

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

template<typename T, typename F>
void mapWithIndex(std::vector<T> vec, F fun) {
   for(int i = 0; i < vec.size(); i++) 
       fun(vec[i], i); 
}

int main() {
   std::vector<std::string> vec = {"hello", "cup", "of", "tea"};
   mapWithIndex(vec, [](std::string s, int i){
      std::cout << i << " " << s << '\n';
   } );
}