#include <vector>
#include <string>
#include <iostream>

using namespace std;

int main(){

    vector<int> v={76987,876,3464,908}; // nowy sposób inicjalizacji
                                        // zamiast push_back
    
    for(int i=0;i<v.size();i++){ // klasyczne iterowanie po wektorze
        v[i]=1000;
    	cout << v[i] << endl;
    }

    return 0;
}

Pętle

Rozbijamy pętlę

1. indeks
2. wartość w wektorze wskazywana przez indeks

int main(){

    vector<int> v={76987,876,3464,908};
       
    // indeks na zerowy element w wektorze
    int i=0; 
    
    // odwołanie do elementu
    cout << v[i]; 

    // przesunięcie indeksu
    // na kolejny element
    i++; 
    
    v[i]=1000; // modyfikujemy element
    cout << v[i]; // odwołanie do elementu

    // ...

    if(i!=v.size()){ // sprawdzanie, 
                     // czy jesteśmy
                     // w zakresie
        
    return 0;
}

Iterator

int main(){

    vector<int> v={76987,876,3464,908};
       
    // indeks na zerowy element w wektorze
    int i=0; 
    
    // odwołanie do elementu
    cout << v[i]; 

    // przesunięcie indeksu
    // na kolejny element
    i++; 

    v[i]=1000; // modyfikujemy element
    cout << v[i]; // odwołanie do elementu

    // ...

    if(i!=v.size()){ // sprawdzanie, 
                     // czy jesteśmy
                     // w zakresie
        
    return 0;
}

1. połączenie indeksu
2. z dostępem do elementu w wektorze
3. i przejściem do kolejnego elementu

int main(){

    vector<int> v={76987,876,3464,908};
       
    // indeks na zerowy element w wektorze
    int i=0; // (1)
    
    // odwołanie do elementu
    cout << v[i]; // (2)

    // przesunięcie indeksu
    // na kolejny element
    i++; // (3)

    v[i]=1000; // modyfikujemy element
    cout << v[i]; // odwołanie do elementu (2)

    // ...

    if(i!=v.size()){ // sprawdzanie, 
                     // czy jesteśmy
                     // w zakresie
        
    return 0;
}

Iterator

1. połączenie indeksu
2. z dostępem do elementu w wektorze
3. i przejściem do kolejnego elementu

int main(){

    vector<int> v={76987,876,3464,908};
    
    // odwołanie do początku wektora
    iterator it=v.begin(); // (1)

    // odwołanie do elementu
    cout << *it; // (2)

    // przesunięcie iteratora 
    // na kolejny element
    it++; // (3)

    *it=1000; // modyfikujemy element
    cout << *it; // odwołanie do elementu (2)

    // ...

    if(it!=v.end()){ // sprawdzanie, 
                     // czy jesteśmy
                     // w zakresie
        
    return 0;
}

int main(){

    vector<int> v={76987,876,3464,908};
       
    for(int i=0;i<v.size();i++){
        v[i]=1000;
    	cout << v[i] << endl;
    }
        
    return 0;
}

Iterator - Pętla

składamy wiedzę o iteratorze z powrotem w pętlę

int main(){

    vector<int> v={76987,876,3464,908};
    
    for(iterator it=v.begin();it!=v.end();it++){
        *it = 1000;
        cout << *it << endl;    
    }
        
    return 0;
}

int main(){

    vector<int> v={76987,876,3464,908};
       
    for(
        int i=0;
        i<v.size();
        i++
        ){
            v[i]=1000;
    	    cout << v[i] << endl;
    }
        
    return 0;
}

Deklaracja typu iteratora

Niestety, właściwa nazwa typu iteratora jest mocno nieintuicyjna i "przegadana".

vector<int>::iterator it1=v.begin();

vector<int>::iterator it2=v.end();

int main(){

    vector<int> v={76987,876,3464,908};
    
    for(
        vector<int>::iterator it=v.begin();
        it!=v.end();
        it++
        ){
           *it=1000;
           cout << *it << endl;    
    }
        
    return 0;
}

int main(){

    vector<int> v={76987,876,3464,908};
       
    for(
        int i=0;
        i<v.size();
        i++
        ){
            v[i]=1000;
    	    cout << v[i] << endl;
    }
        
    return 0;
}

Deklaracja typu iteratora

Dlatego skorzystamy ze słowa kluczowego auto, które wymusza na kompilatorze samodzielne dopasowanie typu.

auto it1=v.begin();

auto it2=v.end();

int main(){

    vector<int> v={76987,876,3464,908};
    
    for(
        auto it=v.begin();
        it!=v.end();
        it++
        ){
           *it=1000;
           cout << *it << endl;    
    }
        
    return 0;
}

Operacja na iteratorze

1. otrzymanie iteratora z wektora
2. przesunięcie iteratora
3. dostęp do elementu z wektora

int main(){

    vector<int> v={76987,876,3464,908};

    auto iterator = v.begin();
    auto iterator_koniec = v.end();

    iterator++; // przesuwamy na następny element 
    iterator--; // można też na poprzedni

    if(iterator == iterator_koniec){
        cout << "iteratory można porównywać!"    
    }   

    if(iterator != iterator_koniec){
        cout << "iteratory można porównywać!"    
    }

    *iterator = 7; // gwiazdka umożliwia dostęp do elementu
                   // za iteratorem, w tym przypadku
                   // zmodyfikowaliśmy wartość pierwszego elementu
                   // wektora 
    return 0;
}

begin() end()

++ --

*

Kilka uwag na koniec

1. Porównując iteratory używaj != oraz ==
2. Korzystanie z    >   >=   <=   <    jest potrzebne dla sytuacji, których zastosowanie poruszymy na kolejnych wykładach
3. Iteratory można do siebie przypisywać

int main(){

    vector<int> v={76987,876,3464,908};

    auto iterator = v.begin();
    auto iterator_koniec = v.end();
    
    auto iterator2 = v.begin();

    iterator++; // przesuwamy na następny element 
    iterator--; // można też na poprzedni

    iterator2=iterator;

    *iterator2 = 7; // gwiazdka umożliwia dostęp do elementu
                   // za iteratorem, w tym przypadku
                   // zmodyfikowaliśmy wartość pierwszego elementu
                   // wektora 
    return 0;
}