🌳 std::map vs 🖥 std::unordered_map

Две ассоциативные структуры, два разных назначения.

map

— Красно-чёрное дерево
— Операции за O(log n)
— Сохраняет сортировку ключей

unordered_map

— Хеш-таблица
— Амортизированная O(1)
— Нет сортировки
Но, может переполняться и ребалансироваться

std::unordered_map<std::string, int> id;
id["Alice"] = 5;

💡 Если нужны сортированные ключи — map. Если нужна скорость — unordered_map.

🤓 std::algorithm

STL-алгоритмы работают над итераторами, а не над контейнерами — поэтому они универсальны.

std::vector<int> v = {1, 2, 3, 4};

auto it = std::find(v.begin(), v.end(), 3);

std::reverse(v.begin(), v.end());

std::sort(v.begin(), v.end());

Полезные алгоритмы, которые могут быть полезны:

std::partition — разбивает по условию

std::unique — убирает дубликаты (но не меняет размер!)

std::any_of, std::none_of, std::all_of

💡 Комбинируя алгоритмы и лямбды, можно писать универсальный и масштабируемый код.

🔍 std::optional, std::variant, std::any: современный STL

Современный C++ даёт инструменты для более безопасного кода:

std::optional

Хранит “значение или отсутствие значения”.

std::optional<int> try_parse(const std::string& s);

std::variant

Безопасный union, работающий через типы.

variant<int, string> v = "hello";

std::any

Хранит любое значение, но требует приведения типа.

😏 Чаще используют optional или variant. Any — на крайняк

😉 std::deque — недооценённый контейнер

std::deque — гибрид между std::vector и std::list:

— Быстрые вставки в начало и конец

— Почти такой же быстрый доступ по индексу, как у vector

— Не хранит данные в одном непрерывном блоке

std::deque<int> d = {1, 2, 3};
d.push_front(0);
d.push_back(4);

💯 Если вам нужен “двухсторонний vector” — это он

🔍 std::string_view — мнимые строки

std::string_view — неблокирущий, не владеющий срез строки.

— Дешёвый аргумент, парсер, логирование

void log(std::string_view msg) {
    std::cout << msg;
}

⚠️ Никакой гарантии жизни источника, это просто "окно в строку".

❗️Частая ошибка:

std::string_view sv = std::string("temp"); // UB

🎯 Используйте в сигнатурах вместо const std::string&.

🗂 std::priority_queue — очередь, но с приоритетами

std::priority_queue<int> q;
q.push(5);
q.push(1);
q.push(10);
std::cout << q.top(); // 10

Особенности:

— Нельзя итерироваться

— Нет erase

— Только top/pop/push

— Доступ только к максимальному элементу

🔑 Если вам нужна структура данных “выдай максимум/минимум” — это ваш выбор

🖥 std::set vs std::unordered_set

std::set — дерево
std::unordered_set — хеш-таблица

std::set<int> s;
s.insert(3);

Особенности std::set :

— Сортированные элементы

— Медленнее, но предсказуемо (O(log n))

— Имеет lower_bound/upper_bound

Особенности std::unordered_set

— Быстро — O(1)

— Нет сортировки

— Выгоден для больших объёмов

✅ Если нужно проверить есть ли элемент — std::unordered_set практически всегда быстрее.

🔄 std::transform: функциональный стиль в C++

Преобразует диапазон элемент за элементом

std::vector<int> a = {1,2,3};
std::vector<int> b(3);

std::transform(a.begin(), a.end(), b.begin(), [](int x){ return x * 2; });

Особенности:

— Применять лямбды к контейнерам

— Копировать с изменением

— Комбинировать два диапазона

std::transform(a.begin(), a.end(), c.begin(), std::back_inserter(out), std::plus<>{});

⌨️ Если пишете цикл для каждого элемента — почти всегда можно заменить на std::transform.

🎯 auto и const: подводный камень

const int x = 10;
auto a = x;
auto& b = x;

Что здесь происходит?

a — копия, const отброшен

b — ссылка на const int

💡 auto отбрасывает const и ссылку, если они не указаны явно

😉 Move ≠ Copy

std::string a = "hello";
std::string b = std::move(a);

Многие думают, что a очищается. Это не совсем так...

🔍 RAII и исключения

void f() {
    std::lock_guard<std::mutex> g(m);
    throw std::runtime_error("error");
}

🌃 virtual деструктор

struct Base {
    ~Base() = default;
};

struct Derived : Base {
    ~Derived() { std::cout << "dtor\n"; }
};

Base* b = new Derived;
delete b;

💻 std::vector и инвалидирование

std::vector<int> v = {1,2,3};
auto it = v.begin();
v.push_back(4);