Pythona jak wyliczenie pętli w C++

Question

Powiel możliwe:
Find position of element in C++11 range-based for loop?

mam vector i chciałbym iteracyjne go, a jednocześnie mają dostęp do indeksy dla każdego elementu (muszę przekazać zarówno element, jak i jego indeks do funkcji). Rozważałem następujące dwa rozwiązania:

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

Zastanawiam się, czy może być bardziej kompaktowe rozwiązanie. Coś podobnego do Pythona enumerate. To jest najbliższe, co mam za pomocą pętli zasięgu C++ 11, ale określenie indeksu poza pętlą w prywatnym zakresie zdecydowanie wydaje się gorszym rozwiązaniem niż 1 lub 2:

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

Czy jest jakiś sposób (być może za pomocą funkcji Boost), aby uprościć najnowszy przykład w taki sposób, aby indeks znalazł się w pętli?

Answer 1

Jako @Kos mówi, jest to taka prosta sprawa, że ​​tak naprawdę nie widzi potrzeby dalszego uproszczenia go i osobiście po prostu trzymać się tradycyjnych dla pętli z indeksów, z wyjątkiem, że będę rowu std::vector<T>::size_type i po prostu użyć std::size_t:

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

nie jestem zbyt chętni do roztworu 2. wymaga (kinda ukryte) random access iteratory które nie pozwalają łatwo zamienić pojemnik, który jest jednym z silnych punkty iteratorów. Jeśli chcesz użyć iteratorów i uczynić go generic (i ewentualnie ponieść spadek wydajności, gdy iteratory są nie dostępie swobodnym), polecam korzystania std::distance:

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

Answer 2

Jednym ze sposobów jest zawarcie pętli w funkcji własnej.

#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

Oto niektóre zabawne rozwiązanie używając leniwą ocenę. Po pierwsze, zbudować obiekt generatora 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 }; 
     } 
}; 

Następnie utwórz enumerate funkcji wrapper który będzie wydedukować argumenty szablon i powrotu generatora:

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

Teraz można korzystać z funkcji w ten sposób:

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

Powyższa implementacja jest zwykłą zabawką: powinna działać zarówno z wartością l. const, jak i non-const s jak i rvalue-references, ale ma rzeczywisty koszt dla tego drugiego, biorąc pod uwagę, że kopiuje cały iterowalny obiekt kilka razy. Ten problem z pewnością można rozwiązać za pomocą dodatkowych poprawek.

ponieważ C++ 17, deklaracje rozkładu nawet pozwalają mieć chłodną python-jak składni do nazywania indeks i wartość bezpośrednio w for inicjatora:

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

nie mam do C++ Kompilator zgodny z 17 pod ręką, aby to sprawdzić, ale mam nadzieję, że auto&& w rozkładzie jest w stanie wywnioskować index jako std::size_t i value jako double&.