類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

由於@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 2

一種方法是將循環包裝在您自己的函數中。

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

Answer 3

下面是使用某種有趣的解決方案懶惰的評價。首先，構建發電機對象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 }; 
     } 
}; 

然後，創建一個包裝函數枚舉會推斷出模板參數和返回發電機：

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左值參考工作s以及右值引用，但是對於後者來說，它具有實際的代價，考慮到它複製整個可迭代對象多次。這個問題肯定可以通過額外的調整來解決。

由於C++ 17，分解聲明甚至允許你有涼爽的Python的語法來命名索引並直接在for初始值：

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

我沒有一個C++ 17兼容的編譯器來檢查它，但我希望分解中的auto&&能夠推斷index爲std::size_t和value爲double&。