Pierwszy - podstawy i iteratory

#include <iostream>
#include <utility>
#include <vector>
#include <random>
#include <algorithm>


using namespace std;
void wypisz(vector<int> &wektor)
{
    for(auto &kazdy:wektor)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
}
void wypisz(vector<short> &wektor)
{
    for(auto &kazdy:wektor)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
}

int main() {
        vector<int> pusta_tablica; // nie ma nic nie [0]
                                        // 0 1 2 ... 9  indeksy
        vector<int> tablica(10); // 0 0  0 0 .. 0 wartosci
        vector<int> tablica_zainicjalizowana(10,5);
       cout<<"Wypisuje pusta tablice "<<endl;
        /// auto zastępuje dowolny typ

        for(int kazdy:pusta_tablica) // inaczej można tą pętle zapisać
        {
            cout<<kazdy<<" ";
        }
//         for(int i =0;i<pusta_tablica.size();i++) //<- wersja konwencjonalna
//          {
//           cout<<pusta_tablica[i]<<" ";
//           }
//             for(vector<int>::iterator poczatek=pusta_tablica.begin();poczatek!=pusta_tablica.end();poczatek++)// <- wersja alternatywna z iteratorem
//             {
//             cout<<*poczatek<<" ";
//             }

        cout<<endl;
    cout<<"Wypisuje tablice w domysle zainicjalizowana zerami  "<<endl;
    for(auto kazdy:tablica)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
    cout<<"Wypisuje tablice w domysle zainicjalizowana 5-tkami  "<<endl;
    for(auto kazdy:tablica_zainicjalizowana)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
    cout<<"Dodaje i wypisuje do (kopi) kazdego elementu liczbe 2   "<<endl;
    for(auto kazdy:tablica)
    {
        kazdy+=2;
        cout<<kazdy<<" ";
    }
    cout<<endl;
    cout<<"Mimo przejscia po wszystkich elementach tablicy tablica pierwotna zostala bez zmian    "<<endl;
    for(auto kazdy:tablica)
    {

        cout<<kazdy<<" ";
    }
    cout<<endl;
    //int *ades=&tablica_zainicjalizowana[0];

    for(auto &kazdy:tablica) // użycie referencji przed typem
    {
        kazdy+=99;
    }
    for(auto kazdy:tablica)
    {

        cout<<kazdy<<" ";
    }
    /*
     * for( typ nazwa:nazwa_tablicy) // dla każdego elementu
     *
     * {
     * }
     */
    cout<<endl;
    int i=0;
    pusta_tablica=tablica_zainicjalizowana;// operator = działa tak samo jak dla zwykłych typów ( pusta_tablica będzie miała rozmiar i wartosci takie same jak tablica zainicjalizowana)
 /*
  * Przewagi wektorów nad dynamicznymi tablicami
  * ->Do wektorów można łatwo dodawać nowe elementy
  * ->W wektorach można zmieniać długość wektora w dość prosty sposób
  * ->Wektory posiadają metodę która zwraca ilość elementów w tej tablicy
  * ->Poprzez posiadanie iteratora(coś ala wskaźnik) można w łatwy sposób iterować oraz po danych elementach NIE znając długości tej tablicy
  * ->Można skorzystać z gotowych rozwiązań do 1) sortowania 2) zamiany 3) wstawiania elementów w środek i inne
  */
 cout<<"Pokazuje ze operator przypisania wektora do wektora dziala "<<endl;
    for(int i =0;i<pusta_tablica.size();i++)
    {

        cout<<pusta_tablica[i]<<" ";
    }
    cout<<endl;
    pusta_tablica.clear(); // czyści nam tablicę do pierwotnego stanu // nic nie będzie w puustej tablicy
    cout<<"A tutaj ze metoda clear() usuwa nam wszystkie elementy w wektorze "<<endl;
    wypisz(pusta_tablica);

    for(int i=0;i<20;i++)
    {
        pusta_tablica.push_back(i+1);// dodajemy nowy element poprzez metodę push_back(wartosc)

    }
    for(int kazdy:pusta_tablica)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
    for(int i=0;i<5;i++)
    {
        pusta_tablica.pop_back();
    }
    for(int kazdy:pusta_tablica)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
    pusta_tablica.erase(pusta_tablica.begin(),pusta_tablica.begin()+5);

    for(int kazdy:pusta_tablica)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
   // pusta_tablica.clear();
   // wypisz(pusta_tablica);


    pusta_tablica.erase(pusta_tablica.end()-5,pusta_tablica.end());

    for(int kazdy:pusta_tablica)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl;
    cout<<endl;
    uniform_int_distribution<short> funkcja (-100,300);
    default_random_engine silnik;
    vector<short> nowe;

    for(int i=0;i<300;i++) //300 lub więcej nie spowoduje błędów
    {
        short cos=funkcja(silnik);
        nowe.push_back(cos);
        cout<<nowe[i]<<" ";
    }
    cout<<endl;
    sort(nowe.begin(),nowe.end());
    wypisz(nowe);
    vector<short>::iterator iterator=nowe.begin();
    for(auto kazdy:nowe)
    {
        if(kazdy<135)
        {
            iterator++;
        }
    }
    cout<<endl<<endl;

    nowe.erase(nowe.begin(),iterator);

    wypisz(nowe);

    for(int i=0;i<50;i++)
    {
        nowe.erase(nowe.rbegin().base()-1);
    }
    cout<<endl;
    wypisz(nowe);
    sort(nowe.begin(),nowe.end(),greater<short>());
    wypisz(nowe);
    vector<short>::reverse_iterator tylny= nowe.rbegin();
    vector<short>::reverse_iterator przedni= nowe.rend();
    cout<<"Wypisuje wyluskanie reverse itteratora wektora nowe wskazujacego na rbegin(czyli ostatni element)  "<<*tylny<<endl;
    cout<<"Wypisuje wyluskanie reverse itteratora wektora nowe wskazujacego na rend(czyli pierwszy element) "<<*(przedni-1)<<endl;
    // nie działa normalne wypisanie gdyż reverse iterator ma ideks o 1 mniejszy niż jego odpowiednik
    // dlatego teraz pokażę jeden z błędów jakie może powodować iterowanie po iteratorach
    for(auto iterator= nowe.begin();iterator!=nowe.end();iterator++)
    {
        cout<<*iterator<<" ";
    }

   // short * wskaznik=& *nowe.begin();

    cout<<endl<<endl;
    for(auto iterator= nowe.end()-1;iterator!=nowe.begin();iterator--)
    {
        cout<<*iterator<<" ";
    }
    // by uniknąć błędu wyjścia i próby wyłuskania elementu nie znajdującego się we wektorze zastosujemy reverse iterator
    cout<<endl<<endl;
    for(auto iterator= nowe.rend();iterator.base()!=nowe.begin();iterator++)
    {
        cout<<*iterator<<" ";
    }
    cout<<endl<<endl;
    // możemy łatwo sprawdzić rozmiar / dystans między 2-ma iteratorami operującymi na tym samym wektorze
    int dystans_w_nowe=distance(nowe.begin(),nowe.end());// da taki sam wynik jak .size()
    if(dystans_w_nowe==nowe.size())
    {
        cout<<"Dystans jest taki sam jak wartosc zwracana z metody .size()"<<endl;
    }

    /*
     * By się pozbyć wielu elementów z przodu albo z tułu , chcemy nie brać pod np kilku wartości z przodu lub z tyłu
     *  możemy używając funkcji advance ( iter przesuwany_iterator,int o_ile_przesunac_i_gdzie)
     * advance(
     */
    auto przedni_iterator=nowe.begin(),tylni_iterator=nowe.end();
    //np chcemy wziąść 20 okolo elementow ze środka

    advance(przedni_iterator,distance(nowe.begin(),nowe.end())/2 -10);
    advance(tylni_iterator,-distance(nowe.begin(),nowe.end())/2 +10) ;

    cout<<endl<<distance(przedni_iterator,tylni_iterator)<<endl;

    for(int i=0;przedni_iterator!=tylni_iterator;przedni_iterator++)
    {
        i++;
        cout<<*przedni_iterator<<" "<<i<<endl;
    }
    cout<<endl<<nowe.size()<<endl;
    nowe.erase(nowe.begin()+10,nowe.begin()+40);
    for(auto kazdy:nowe)
    {
        cout<<kazdy<<" ";
    }
    cout<<endl<<nowe.size();
//    vector<int>::iterator nowy=pusta_tablica.begin();
//    nowy+=10;
    return 0;
}