Comment faire une boucle à travers un std :: vecteur dans les cycles répétitifs

Question

J'utilise un std::vector avec C++ pour stocker quelques éléments & les récupérer plus tard. Voici comment je parcours mon vecteur.

std::vector<some_object> some_vector; 
some_vector.resize(10); 

for (auto it = some_vector.begin(); it != some_vector.end(); ++it) { 
    int current_it_index = std::distance(some_vector.begin(), it); 
} 

J'ai besoin de l'index par itération. Donc, en le récupérant par itération comme démontré ci-dessus.

Au-dessus de la boucle fonctionne bien mais je veux boucle à travers le vecteur dans les cycles infinis. Comment puis je faire ça?

Maintenant, je comprends que la question vient, Comment arrêtez-vous la boucle en cours d'exécution si vous le laissez fonctionner en répétant des cycles. Je pense à utiliser un std::atomic<bool> comme une variable pour signaler & sortir de la boucle qui devrait fonctionner plutôt bien?

PS: Notez que j'ai pris std::vector comme exemple de conteneur pour expliquer la question. Ce serait génial si la solution suggérée pouvait fonctionner sur std::array ou d'autres conteneurs.

Answer 1

std::vector<some_object> some_vector; 
some_vector.resize(10); 
bool quit = false; 
while (!quit) { 
    for (auto& e:some_vector) { 
    if (quit) break; 
    std::size_t i = std::addressof(e)-some_vector.data(); 
    // ... 
    } 
} 

Answer 2

Une astuce courante pour itérer à travers un tableau qui a une puissance de 2 nombre d'éléments consiste simplement à itérer un compteur et à utiliser une opération de masque.

size_t counter = 0; 
const size_t mask = some_vector.size() - 1U; 

while (!quit) { 
    size_t i = counter++ & mask; 
    do_something(some_vector[i]); 
} 

Si le tableau n'est pas une puissance de deux, vous pourriez effectuer des opérations arithmétiques modulo au lieu de masquer un compteur de course libre.

size_t i = 0; 
const size_t n = some_vector.size(); 

while (!quit) { 
    do_something(some_vector[i++]); 
    i %= n; 
} 

Si vous utilisez un conteneur d'accès non aléatoire, et ont besoin d'itérateurs et les index, vous pouvez mettre en œuvre deux boucles. Cela éviterait le coût du calcul distance sur un itérateur d'accès non aléatoire.

for (;;) { 
    size_t idx = 0; 
    for (auto it = some_container.begin(); 
     it != some_container.end(); 
     ++it) { 
     do_something(it, idx++); 
    } 

Answer 3

Si je comprends bien, ce que vous voulez est que lorsque vous obtenez au dernier élément de votre conteneur, vous sautez simplement au début du conteneur à nouveau. Nous pouvons facilement le code qui assez:

auto first = std::begin(c); 
const auto last = std::end(c); 
std::size_t idx = 0; 

while (!should_exit()) { 
    do_something(idx); 

    ++idx; 
    if (++first == last) { // reset 
     idx = 0; 
     first = std::begin(c); 
    } 
} 

Cela devrait fonctionner pour tout conteneur de type STL. Avoir à la fois l'itérateur et l'index est peut-être inutile, mais c'est une solution KISS qui fonctionnera pour les conteneurs à accès non-aléatoire comme std::list ainsi que vector/array.