Como navegar por um vetor usando iteradores? (C ++)

O objetivo é acessar o "enésimo" elemento de um vetor de strings em vez do operador [] ou do método "at". Pelo que entendi, os iteradores podem ser usados ​​para navegar por contêineres, mas nunca usei iteradores antes, e o que estou lendo é confuso.

Se alguém pudesse me dar algumas informações sobre como conseguir isso, eu agradeceria. Obrigado.

Você precisa usar o método begine endda vectorclasse, que retorna o iterador referindo-se ao primeiro e ao ú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, os iteradores são usados ​​para acessar elementos de um contêiner de maneira linear; entretanto, com "iteradores de acesso aleatório", é possível acessar qualquer elemento da mesma maneira que operator[].

Para acessar elementos arbitrários em um vetor vec , você pode usar o seguinte:

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

A seguir está um exemplo de um padrão de acesso típico (versões anteriores de C ++):

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

A vantagem de usar o iterador é que você pode aplicar o mesmo padrão a outros contêineres :

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

Por esse motivo, é realmente fácil criar um código de modelo que funcione da mesma forma, independentemente do tipo de contêiner . Outra vantagem dos iteradores é que ele não assume que os dados residem na memória; por exemplo, pode-se criar um iterador direto que pode ler dados de um fluxo de entrada ou que simplesmente gera dados em tempo real (por exemplo, um intervalo ou gerador de números aleatórios).

Outra opção usando std::for_eache lambdas:

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

Desde C ++ 11, você pode usar autopara evitar a especificação de um nome de tipo muito longo e complicado do iterador como visto antes (ou ainda mais complexo):

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

E, além disso, há uma variante mais simples para cada:

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

E, finalmente, há também std::accumulateonde você deve ter cuidado ao adicionar números inteiros ou números de ponto flutuante.

Em C ++ - 11, você pode fazer:

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

Veja aqui as variações: https://en.cppreference.com/w/cpp/language/range-for

Os iteradores do Vector são iteradores de acesso aleatório, o que significa que eles se parecem e funcionam como ponteiros simples.

Você pode acessar o enésimo elemento adicionando n ao iterador retornado do begin()método do contêiner ou pode usar o 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, você pode usar a função de avanço que funciona com todos os tipos de iteradores. (Você teria que considerar se realmente deseja realizar "acesso aleatório" com iteradores de acesso não aleatório, já que isso pode ser uma coisa cara de se fazer.)

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

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

Aqui está um exemplo de acesso ao ithíndice de a std::vectorusando um std::iteratordentro de um loop que não requer o incremento de dois 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());
    }
}

Sem for-loop

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

e usando o atmétodo:

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