C++ base guide 4

#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <algorithm>

using namespace std;

struct S {
    int a;
};

int main() {
    // использование итераторов в векторах
    vector<int> v = { 1, 2, 3, 4, 5, 3, 4 };
    vector<S> v2 = { {3}, {2}, {3}, {4} };

    // можем выводить вектор с помощью итератора
    for (auto it = v2.begin(); it != v2.end(); ++it) {
        // две одинаковые по функционалу записи
        cout << (*it).a << " ";
        cout << it->a << " ";
    }

    // rbegin и rend, чтобы "развернуть" итераторы
    // мы получаем уже reverse итераторы
    // rbegin указывает на последний элемент, и его увеличение будет
    // двигать нас к началу, rend указывает "перед" первым элементом
    for (auto it = v2.rbegin(); it != v2.rend(); ++it) {
        // две одинаковые по функционалу записи
        cout << (*it).a << " ";
        cout << it->a << " ";
    }

    // можем вставлять в вектор, укзаывая позицию для вставки при помощи итератора
    // вставить на вторую позицию
    v.insert(v.begin() + 2, 45);
    // аналогично можем удалять (удаляем 3 элемент)
    v.erase(v.begin() + 3);
    // удаляем предпоследний
    v.erase(v.end() - 2);
    // стоит помнить, что обе функции работают в хужшем случае за O(n)
    // (конечно, все зависит от того, куда вставляете)

    // разворачиваем вектор. Для этого передаем итератор на начало
    // разворачиваемой последовательности и на конец
    reverse(v.begin(), v.end());
    // итераторы вектора можно двигать на число в сторону, поэтому
    // можем указать не весь вектор, а его подотрезок (например, с 1 по 5 элемент)
    reverse(v.begin() + 1, v.end() - 1);
    // вызовет ошибку, так как пытаемся выйти за границы вектора итератором
    // левее begin и правее end уходить нельзя
    reverse(v.begin() - 1, v.end() - 1);

    // абсолютно аналогично можем заполнять вектор
    fill(v.begin(), v.end(), 1);
    fill(v.begin() + 2, v.end() - 1, 1);

    // для сортировки понадобится библиотека algorithm
    // работает за O(nlog(n))
    // все точно так же, указываем итераторы на начало и
    // конец сортируемой последовательности
    sort(v.begin() + 2, v.end());



    // переходим к set, для этого подключаем одноименную библиотеку
    // set - множество уникальных элементов, то есть в нем не бывает дубликатов
    // хранит элементы в отсортированном по возрастанию порядке
    set<int> st = { 4, 2, 1 };

    // обычный for auto по-прежнему работает
    // получим на выходе элементы в отсортированном порядке, то есть
    // 1 2 4
    for (auto x : st) {
        cout << x << "\n";
    }
    // выводим set при помощи итераторов, вывод тот же - 1 2 4
    for (auto it = st.begin(); it != st.end(); ++it) {
        cout << *it << " ";
    }
    cout << "\n";

    // добавление элемента в set
    st.insert(5);
    // эти операции не изменят set, так как в нем уже есть 5
    st.insert(5);
    st.insert(5);
    st.insert(5);
    st.insert(5);

    // удаление элемента по значению
    st.erase(5);
    // опять никакого эффекта
    st.erase(5);
    st.erase(5);
    // можем удалить и по итератору, для этого сначала вызовем find
    // find возвращает итератор на элемент с тем же значением или st.end(), если
    // в set такого элемента не оказалось
    auto it = st.find(2);
    // если попытаемся st.erase(st.end()) - краш
    st.erase(it);

    // можем таким образом проверять, есть ли элемент
    if (st.find(2) == st.end()) {
        cout << "Элемента нет";
    }

    // извращённый метод удаления нужного элемента
    for (auto it = st.begin(); it != st.end();) {
        auto it_tmp = it;
        it++;
        if (*it_tmp == 2) {
            st.erase(it_tmp);
        }
    }

    // хотим удалить второй в порядке сортировки элемент, но, в отличие от вектора,
    // итераторы set нельзя двигать в сторону на число, приходится костылять
    auto it = st.begin();
    ++it;
    ++it;
    st.erase(it);

    // set не хранится в памяти последовательно, поэтому использовать указатели
    // для его обхода не получится, пример наглядно это демонстрирует
    // первый элемент совпадет, а дальше пойдет мусор
    int i = 0;
    for (const int* p = &(*st.begin()); i < 3; ++i, ++p) {
        cout << *it << " ";
    }



    // переходим к map, снова библиотека с именем контейнера
    // словарь. Хранит пары { ключ, значение }, в <> указываем тип
    // ключа и значения соответственно
    // элементы отсортированы по ключам
    map<string, int> mp = { {"sad", 3}, {"one", 4}, {"dd", 211} };
    // создали элемент с ключом "one"
    mp["one"] = 12321;
    // увеличили элемент с ключом "sad"
    mp["sad"]++;
    // так как элемента с таким ключом у нас нет, то map сначала создаст его
    // и присвоит базовое значение (для int это 0), а потом уже применит к нему ++
    // получим 1
    mp["s"]++;

    // вставка пары { ключ, значение } (понятия не имею, зачем она вам может пригодиться)
    // используйте квадратные скобки
    mp.insert({ "sa", 22 });
    // единственное преимущество - можем получить итератор на вставленный элемент
    auto it = mp.insert({ "one", 23 });
    // удаление по ключу
    mp.erase("onesadsa");
    // или итератору
    mp.erase(mp.begin());

    // извращенный метод удаления по ключу через итератор
    // find работает как в set
    if (mp.find("one") != mp.end()) {
        mp.erase(mp.find("one"));
    }

    // обход map, в x оказывается очередная пара { ключ, значение }
    for (auto x : mp) {
        cout << "Ключ: " << x.first << ", значение: " << x.second << "\n";
    }
    // более элегантный метод обхода
    for (auto [k, v] : mp) {
        cout << "Ключ: " << k << ", значение: " << v << "\n";
    }
    // и, конечно, обход итераторами
    for (auto it = mp.begin(); it != mp.end(); ++it) {
        cout << it->first << " " << it->second << "\n";
    }
    return 0;
}