¿Cómo navegar por un vector usando iteradores? (C ++)

El objetivo es acceder al elemento "n-ésimo" de un vector de cadenas en lugar del operador [] o el método "at". Por lo que tengo entendido, los iteradores se pueden usar para navegar a través de contenedores, pero nunca antes había usado iteradores y lo que estoy leyendo es confuso.

Si alguien pudiera darme alguna información sobre cómo lograrlo, se lo agradecería. Gracias.

Debe hacer uso del método beginy endde la vectorclase, que devuelve el iterador que hace referencia al primer y último elemento respectivamente.

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.

Normalmente, los iteradores se utilizan para acceder a elementos de un contenedor de forma lineal; sin embargo, con los "iteradores de acceso aleatorio", es posible acceder a cualquier elemento de la misma forma que operator[].

Para acceder a elementos arbitrarios en un vector vec , puede utilizar lo siguiente:

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

El siguiente es un ejemplo de un patrón de acceso típico (versiones anteriores de C ++):

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

La ventaja de usar iterador es que puede aplicar el mismo patrón con otros contenedores :

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

Por esta razón, es realmente fácil crear un código de plantilla que funcione igual independientemente del tipo de contenedor . Otra ventaja de los iteradores es que no asume que los datos residen en la memoria; por ejemplo, se podría crear un iterador directo que pueda leer datos de un flujo de entrada, o que simplemente genere datos sobre la marcha (por ejemplo, un generador de rango o de números aleatorios).

Otra opción usando std::for_eachy lambdas:

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

Desde C ++ 11, puede utilizar autopara evitar especificar un nombre de tipo muy largo y complicado del iterador como se vio antes (o incluso más complejo):

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

Y, además, hay una variante más simple para cada variante:

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

Y finalmente, también hay std::accumulateque tener cuidado si está agregando números enteros o de punto flotante.

En C ++ - 11 puede hacer:

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

Consulte aquí las variaciones: https://en.cppreference.com/w/cpp/language/range-for

Los iteradores de Vector son iteradores de acceso aleatorio, lo que significa que se ven y se sienten como punteros simples.

Puede acceder al enésimo elemento agregando n al iterador devuelto por el begin()método del contenedor , o puede usar el operador [].

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

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

Alternativamente, puede utilizar la función de avance que funciona con todo tipo de iteradores. (Debería considerar si realmente desea realizar un "acceso aleatorio" con iteradores de acceso no aleatorio, ya que eso podría ser algo costoso).

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

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

A continuación, se muestra un ejemplo de cómo acceder al ithíndice de std::vectorun std::iteratordentro de un bucle que no requiere incrementar dos iteradores.

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

Sin un bucle for

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

y usando el atmétodo:

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