Obtenir l'index dans C ++ 11 foreach loop

Est-il un moyen pratique pour obtenir l'index de l'conteneur actuel de l'entrée dans C++11 boucle foreach, comme enumerate en python:

for idx, obj in enumerate(container):
    pass

Que j'ai pu imaginer un itérateur qui peut aussi retourner l'index ou similaire.

Bien sûr, je pourrais avoir un compteur, mais souvent les itérateurs ne pas donner des garanties de l'ordre d'itérer dessus d'un récipient.

source d'informationauteur hildensia

  1. 13

    Une bonne mise en œuvre de la fonctionnalité qui vous sont demandées, peut être trouvé ici:

    https://github.com/ignatz/pythonic

    L'idée derrière est que vous pourrez vous créer un wrapper struct avec un itérateur qui ne le dépouillement. Ci-dessous est très minime mise en œuvre exemplaire pour illustrer l'idée: 

    #include <iostream>
#include <vector>
#include <tuple>
//Wrapper class
template <typename T>
class enumerate_impl
{
public:
//The return value of the operator* of the iterator, this
//is what you will get inside of the for loop
struct item
{
size_t index;
typename T::value_type & item;
};
typedef item value_type;
//Custom iterator with minimal interface
struct iterator
{
iterator(typename T::iterator _it, size_t counter=0) :
it(_it), counter(counter)
{}
iterator operator++()
{
return iterator(++it, ++counter);
}
bool operator!=(iterator other)
{
return it != other.it;
}
typename T::iterator::value_type item()
{
return *it;
}
value_type operator*()
{
return value_type{counter, *it};
}
size_t index()
{
return counter;
}
private:
typename T::iterator it;
size_t counter;
};
enumerate_impl(T & t) : container(t) {}
iterator begin()
{
return iterator(container.begin());
}
iterator end()
{
return iterator(container.end());
}
private:
T & container;
};
//A templated free function allows you to create the wrapper class
//conveniently 
template <typename T>
enumerate_impl<T> enumerate(T & t)
{
return enumerate_impl<T>(t);
}
int main()
{
std::vector<int> data = {523, 1, 3};
for (auto x : enumerate(data))
{
std::cout << x.index << ": " << x.item << std::endl;
}
}
  2. 4

    À propos d'une solution simple comme:

    int counter=0;
for (auto &val: container)
{
makeStuff(val, counter);
counter++;
}

    Vous pourriez faire un peu plus "difficile" pour ajouter le code après le comptoir par l'ajout d'un champ:

    int counter=0;
for (auto &val: container)
{{
makeStuff(val, counter); 
}counter++;}

    @Graham.des roseaux pointus, normal for boucle est aussi une solution, qui pourrait être aussi rapide:

    int counter=0;
for (auto it=container.begin(); it!=container.end(); ++it, ++counter)
{
makeStuff(val, counter);
}

    Et enfin, une voie alternative à l'aide de l'algorithme:

    int counter = 0;
std::for_each(container.begin(), container.end(), [&counter](int &val){ 
makeStuff(val, counter++);
});

    Remarque: l'ordre de l'aire de la boucle et normale de la boucle est garanti par la norme 6.5.4. Sens le compteur est en mesure d'être cohérent avec la position dans le conteneur.

  3. 1

    Si vous avez besoin de l'index puis un traditionnel pour fonctionne parfaitement bien.

    for (int idx=0; idx<num; ++idx)
{
//do stuff
}