Come navigare in un vettore usando gli iteratori? (C ++)

L'obiettivo è accedere all'elemento "nth" di un vettore di stringhe invece dell'operatore [] o del metodo "at". Da quello che ho capito, gli iteratori possono essere usati per navigare attraverso i contenitori, ma non ho mai usato gli iteratori prima e quello che sto leggendo è confuso.

Se qualcuno potesse darmi alcune informazioni su come ottenere questo, lo apprezzerei. Grazie.

È necessario utilizzare il metodo begine enddella vectorclasse, che restituisce l'iteratore che si riferisce rispettivamente al primo e all'ultimo elemento.

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.

In genere, gli iteratori vengono utilizzati per accedere agli elementi di un contenitore in modo lineare; tuttavia, con gli "iteratori ad accesso casuale", è possibile accedere a qualsiasi elemento allo stesso modo di operator[].

Per accedere a elementi arbitrari in un vettore vec , puoi utilizzare quanto segue:

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

Di seguito è riportato un esempio di un tipico modello di accesso (versioni precedenti di C ++):

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

Il vantaggio dell'utilizzo dell'iteratore è che puoi applicare lo stesso modello con altri contenitori :

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

Per questo motivo, è davvero facile creare codice modello che funzionerà allo stesso modo indipendentemente dal tipo di contenitore . Un altro vantaggio degli iteratori è che non presume che i dati siano residenti in memoria; per esempio, si potrebbe creare un iteratore in avanti in grado di leggere i dati da un flusso di input o che semplicemente genera dati al volo (ad esempio un intervallo o un generatore di numeri casuali).

Un'altra opzione che usa std::for_eache lambda:

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

Dal momento che C ++ 11 puoi usare autoper evitare di specificare un nome di tipo molto lungo e complicato dell'iteratore come visto prima (o anche più complesso):

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

Inoltre, c'è una variante più semplice per ogni variante:

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

E infine c'è anche std::accumulatedove devi stare attento se stai aggiungendo numeri interi o in virgola mobile.

In C ++ - 11 puoi fare:

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

Vedi qui per le variazioni: https://en.cppreference.com/w/cpp/language/range-for

Gli iteratori di Vector sono iteratori ad accesso casuale, il che significa che hanno l'aspetto e la sensazione di semplici puntatori.

È possibile accedere all'elemento n-esimo aggiungendo n all'iteratore restituito dal begin()metodo del contenitore oppure è possibile utilizzare 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];

In alternativa puoi usare la funzione Advance che funziona con tutti i tipi di iteratori. (Dovresti considerare se vuoi davvero eseguire "accesso casuale" con iteratori ad accesso non casuale, poiché potrebbe essere una cosa costosa da fare.)

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

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

Ecco un esempio di accesso ithall'indice di un std::vectorutilizzo di un std::iteratorall'interno di un ciclo che non richiede l'incremento di due iteratori.

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

Senza un ciclo for

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

e utilizzando il atmetodo:

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