Comment naviguer dans un vecteur à l'aide d'itérateurs? (C ++)

Le but est d'accéder au "nième" élément d'un vecteur de chaînes au lieu de l'opérateur [] ou de la méthode "at". D'après ce que je comprends, les itérateurs peuvent être utilisés pour naviguer dans les conteneurs, mais je n'ai jamais utilisé d'itérateurs auparavant, et ce que je lis est déroutant.

Si quelqu'un pouvait me donner des informations sur la façon d'y parvenir, je l'apprécierais. Je vous remercie.

Vous devez utiliser la méthode beginand endde la vectorclasse, qui renvoie l'itérateur faisant référence respectivement au premier et au dernier élément.

using namespace std;  

vector<string> myvector;  // a vector of stings.


// push some strings in the vector.
myvector.push_back("a");
myvector.push_back("b");
myvector.push_back("c");
myvector.push_back("d");


vector<string>::iterator it;  // declare an iterator to a vector of strings
int n = 3;  // nth element to be found.
int i = 0;  // counter.

// now start at from the beginning
// and keep iterating over the element till you find
// nth element...or reach the end of vector.
for(it = myvector.begin(); it != myvector.end(); it++,i++ )    {
    // found nth element..print and break.
    if(i == n) {
        cout<< *it << endl;  // prints d.
        break;
    }
}

// other easier ways of doing the same.
// using operator[]
cout<<myvector[n]<<endl;  // prints d.

// using the at method
cout << myvector.at(n) << endl;  // prints d.

En règle générale, les itérateurs sont utilisés pour accéder aux éléments d'un conteneur de manière linéaire; cependant, avec des "itérateurs à accès aléatoire", il est possible d'accéder à n'importe quel élément de la même manière que operator[].

Pour accéder à des éléments arbitraires dans un vecteur vec , vous pouvez utiliser ce qui suit:

vec.begin()                  // 1st
vec.begin()+1                // 2nd
// ...
vec.begin()+(i-1)            // ith
// ...
vec.begin()+(vec.size()-1)   // last

Voici un exemple de modèle d'accès typique (versions antérieures de C ++):

int sum = 0;
using Iter = std::vector<int>::const_iterator;
for (Iter it = vec.begin(); it!=vec.end(); ++it) {
    sum += *it;
}

L'avantage d'utiliser iterator est que vous pouvez appliquer le même modèle avec d'autres conteneurs :

sum = 0;
for (Iter it = lst.begin(); it!=lst.end(); ++it) {
    sum += *it;
}

Pour cette raison, il est vraiment facile de créer un code de modèle qui fonctionnera de la même manière quel que soit le type de conteneur . Un autre avantage des itérateurs est qu'ils ne supposent pas que les données résident en mémoire; par exemple, on pourrait créer un itérateur avant qui peut lire des données à partir d'un flux d'entrée, ou qui génère simplement des données à la volée (par exemple un générateur de plage ou de nombres aléatoires).

Une autre option utilisant std::for_eachet lambdas:

sum = 0;
std::for_each(vec.begin(), vec.end(), [&sum](int i) { sum += i; });

Depuis C ++ 11, vous pouvez utiliser autopour éviter de spécifier un nom de type très long et compliqué de l'itérateur comme vu précédemment (ou même plus complexe):

sum = 0;
for (auto it = vec.begin(); it!=vec.end(); ++it) {
    sum += *it;
}

Et, en plus, il existe une variante plus simple pour chaque variante:

sum = 0;
for (auto value : vec) {
    sum += value;
}

Et enfin, il y a aussi std::accumulatelà où vous devez faire attention si vous ajoutez des nombres entiers ou flottants.

En C ++ - 11, vous pouvez faire:

std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (auto i : v)
{
   // access by value, the type of i is int
   std::cout << i << ' ';
}
std::cout << '\n';

Voir ici pour les variations: https://en.cppreference.com/w/cpp/language/range-for

Les itérateurs de Vector sont des itérateurs à accès aléatoire, ce qui signifie qu'ils ressemblent à des pointeurs simples.

Vous pouvez accéder au nième élément en ajoutant n à l'itérateur renvoyé par la begin()méthode du conteneur , ou vous pouvez utiliser operator [].

std::vector<int> vec(10);
std::vector<int>::iterator it = vec.begin();

int sixth = *(it + 5);
int third = *(2 + it);
int second = it[1];

Vous pouvez également utiliser la fonction avancée qui fonctionne avec toutes sortes d'itérateurs. (Vous devez vous demander si vous voulez vraiment effectuer un "accès aléatoire" avec des itérateurs à accès non aléatoire, car cela pourrait être une chose coûteuse à faire.)

std::vector<int> vec(10);
std::vector<int>::iterator it = vec.begin();

std::advance(it, 5);
int sixth = *it;

Voici un exemple d'accès à l' ithindex d'un en std::vectorutilisant un std::iteratordans une boucle qui ne nécessite pas d'incrémenter deux itérateurs.

std::vector<std::string> strs = {"sigma" "alpha", "beta", "rho", "nova"};
int nth = 2;
std::vector<std::string>::iterator it;
for(it = strs.begin(); it != strs.end(); it++) {
    int ith = it - strs.begin();
    if(ith == nth) {
        printf("Iterator within  a for-loop: strs[%d] = %s\n", ith, (*it).c_str());
    }
}

Sans boucle for

it = strs.begin() + nth;
printf("Iterator without a for-loop: strs[%d] = %s\n", nth, (*it).c_str());

et en utilisant la atméthode:

printf("Using at position: strs[%d] = %s\n", nth, strs.at(nth).c_str());