Тонкости STL, которые часто вылетают в продакшн:

1. Инвалидирование итераторов
При vector::erase все итераторы от позиции удаления до end() становятся «битые». Чтобы безопасно отфильтровать и удалить элементы, пользуйтесь erase–remove идиомой:

   auto it = std::remove_if(v.begin(), v.end(), [](int x){ return x < 0; });
   v.erase(it, v.end());
   

remove_if сдвигает «хвост» вперёд, но не меняет размер контейнера.

2. reserve vs resize

* v.reserve(n) выделяет память, но не создаёт объектов → size() не меняется, можно безопасно push_back.
* v.resize(n) создаёт n элементов, инициализированных значениями по умолчанию.

3. Производительность std::distance
На random-access итераторах (например, vector) это O(1), а на bidirectional или forward (например, list) — O(n). Для списков используйте size() (C++11+) или считайте вручную в критичных местах.

4. emplace_back vs push_back
При сложных типах emplace_back может избежать лишнего копирования:

   v.emplace_back(ctor_arg1, ctor_arg2);
   // vs
   v.push_back(MyType(ctor_arg1, ctor_arg2));
   

5. Памятка про компараторы
В set или map ваш компаратор должен задавать строгий-уровень-менее (operator<): если comp(a,b)==true, то comp(b,a) обязан быть false. Иначе — UB.

Быстро, без воды, но с пользой — проверяйте эти моменты в своём коде!

➡️ @cpp_geek

Пару фишек про шаблоны, которые могут спасти час дебага:

1. CTAD (Class Template Argument Deduction, C++17)
Не надо вручную указывать аргументы:

   std::pair p(42, 3.14); // вместо std::pair<int, double> p(42, 3.14);
   std::vector v = {1,2,3}; // компилятор сам выведет std::vector<int>
   

Помогает сократить код и избежать опечаток.

2. Fold-выражения (C++17) для арг-паков:

   auto sum = [](auto... args){
       return (args + ...);  // ((a + b) + c) + ...
   };
   std::cout << sum(1,2,3,4); // 10
   

Позволяют писать операции над любым числом параметров без рекурсии.

3. SFINAE → Concepts (C++20)
Старый стиль через enable_if легко сломать:

   template<class T>
   std::enable_if_t<std::is_integral_v<T>, T>
   foo(T x) { return x*2; }
   

С Concepts чище и понятнее:

   template<std::integral T>
   T foo(T x) { return x*2; }
   

4. CRTP (Static polymorphism)
Быстрее виртуалок и без RTTI:

   template<class D>
   struct Base {
       void interface() { static_cast<D*>(this)->impl(); }
   };
   struct Derived : Base<Derived> {
       void impl() { std::cout<<"OK\n"; }
   };
   

Шаблоны — это не только про универсальность, но и про ясность кода. Освой тонкости, и они станут 🔧, а не головняком.

➡️ @cpp_geek

🚀 Открой для себя идеальный путь к лидерству с карьерным тестом от ОЭЗ «Алабуга»! 🌟

Мечтаете о карьере в крупной компании, где ваш потенциал раскроется на полную? Наш тест поможет вам определить вашу уникальную лидерскую роль. Может быть, именно вы станете тем лидером, который выведет команду на новый уровень?

После прохождения теста вы можете заполнить заявку и получить приглашение на эксклюзивную лидерскую программу. Участие в программе открывает реальные перспективы трудоустройства в ОЭЗ «Алабуга», предоставляя шанс начать путь к профессиональному признанию.

Сделайте первый шаг к своему будущему сегодня! Пройдите тест, подайте заявку и начните строить свою карьеру вместе с нами. 🎯

Тема: std::optional и return value optimization (RVO)

Когда возвращаешь из функции std::optional<T>, часто задумываешься о лишних копиях. Например, вот так:

std::optional<std::string> make_name(bool valid) {
    if (valid) return "Женя";
    return std::nullopt;
}

Миф: здесь всегда будет копирование строки.
Реальность: современные компиляторы отлично оптимизируют этот код благодаря RVO (Return Value Optimization). Если возвращаемое значение — временный объект, C++ может создать его сразу в том месте, куда он должен быть возвращён. Копий не будет!

Ещё интереснее с C++17: возвращение {} для std::optional<T> и "str" для строки — это всё равно RVO.

⚠️ Но если возвращаешь существующий объект:

std::optional<std::string> wrap(const std::string& s) {
    return s; // здесь копия неизбежна
}

- тут RVO не поможет, потому что возвращаешь уже существующий объект, а не временный.

Вывод:
Не бойся возвращать большие объекты через std::optional! RVO спасает производительность, когда возвращаешь временные объекты.

➡️ @cpp_geek

Сейчас покажу вам простой, но очень полезный приём, как аккуратно и безопасно управлять ресурсами в C++ с помощью RAII (Resource Acquisition Is Initialization).

Когда вы работаете с ресурсами (файлы, сокеты, мьютексы и т.д.), важно не забывать освобождать их. Особенно если программа может завершиться по исключению. И вот тут RAII — наш лучший друг.

Рассмотрим пример:

#include <fstream>
#include <string>

void writeToFile(const std::string& filename, const std::string& data) {
    std::ofstream file(filename);
    if (!file) {
        throw std::runtime_error("Unable to open file");
    }
    file << data;
} // файл автоматически закрывается здесь

Мы открыли файл — и не закрыли его вручную! Почему? Потому что std::ofstream сам закроет его в своём деструкторе. Это и есть RAII в действии.

И теперь представьте: вы можете создавать свои классы с таким же поведением! Например, класс-обёртку над pthread_mutex_t или системным дескриптором.

RAII — это стиль. И это стиль надёжного кода.


➡️ @cpp_geek

Зачем [[nodiscard]] нужен не только для возврата значения

Если ты думаешь, что [[nodiscard]] — это просто защита от игнора Result, то вот фокус: его можно вешать и на классы, и на функции, и даже на enum — и это реально помогает избежать багов.

Пример:

struct [[nodiscard]] Error {
    std::string message;
};

Error do_something() {
    return {"Что-то пошло не так"};
}

void foo() {
    do_something(); // warning: ignoring return value of nodiscard type
}

А теперь магия с методами:

struct Connection {
    [[nodiscard]] bool is_valid() const {
        return valid_;
    }

private:
    bool valid_ = false;
};

void check_connection(const Connection& conn) {
    conn.is_valid(); // warning: result of 'is_valid' is unused
}

📌 Даже если функция возвращает bool — компилятор предупредит, если ты его проигнорируешь. Это круто, когда метод что-то проверяет, ищет или сигналит об ошибке — и ты точно не хочешь забыть проверить результат.

⚠️ Но аккуратно: [[nodiscard]] не бросает исключения и не делает функцию безопасной. Это подсказка компилятору и твой напарник по коду.

Если хочешь писать более надёжный и самодокументируемый код — юзай [[nodiscard]] не только по дефолту, а осознанно.

➡️ @cpp_geek

Ключевые библиотеки Boost, которые полезно знать каждому C++ разработчику

Вот топ-5 библиотек Boost:

1️⃣ Boost.Asio
Асинхронный ввод-вывод и сетевое программирование. Незаменим для серверных приложений.

2️⃣ Boost.Beast
HTTP и WebSocket клиенты/серверы. Построен на Asio.

3️⃣ Boost.Serialization
Сериализация сложных структур данных в потоки байтов и обратно.

4️⃣ Boost.Graph
Алгоритмы на графах: поиск путей, обходы, топологическая сортировка и др.

5️⃣ Boost.Spirit
Создание парсеров прямо в коде C++ без внешних генераторов.

➡️ @cpp_geek

Тема: Почему std::vector<bool> - не совсем std::vector

На первый взгляд std::vector<bool> — обычный вектор, только из булевых значений. Но это особенный шаблон. Вместо хранения bool как полноценного байта, он упаковывает их в биты. Экономит память? Да. Но есть нюансы.

Пример:

std::vector<bool> flags = {true, false, true};
auto x = flags[0];        // Не bool, а прокси-объект!
bool y = flags[0];        // OK — копия значения
bool& z = flags[0];       // Ошибка компиляции

flags[0] возвращает proxy-объект, а не bool&, потому что нельзя вернуть ссылку на бит. Из-за этого:

* Нельзя взять адрес элемента
* Нельзя использовать std::vector<bool> с API, ожидающим bool* или bool&
* Некоторые шаблоны не работают (особенно в generic-коде)

Хочешь экономии — будь готов к сюрпризам. Хочешь предсказуемости — используй std::deque<bool> или std::vector<char>.

⚠️ Кстати, std::vector<bool> — единственная специализация STL-контейнера в стандартной библиотеке.

➡️ @cpp_geek

🚀 Станьте C++ разработчиком и откройте для себя новые возможности в IT.

Актуальное обучение от OTUS — это ваш старт в масштабную разработку на современном подмножестве C++!

👨‍💻 На курсе вы освоите все ключевые аспекты разработки на C++ — от основ синтаксиса до идиом и паттернов языка, продвинутой многопоточности и работы с базами данных Мы подготовим вас для работы с высоконагруженными приложениями, IoT-устройствами и сложными проектами.

⚡️ Изучите C++ с нуля и пройдите два этапа обучения: от Junior до Middle Developer. Реальные кейсы, лучшие практики и советы экспертов помогут вам освоить язык и уверенно претендовать на востребованные позиции.

❗️ Запись на курс закрывается! Оставьте заявку и получите скидку на обучение по промокоду CPPspec_6: https://vk.cc/cN4KR8

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru

Невидимый UB: возвращаем ссылку на локальную переменную

Одна из самых коварных ошибок в C++ — возврат ссылки на переменную, срок жизни которой закончился. Казалось бы, всё компилируется, запускается... и даже иногда "работает". А под капотом — undefined behavior.

Пример:

const std::string& getName() {
    std::string name = "John";
    return name;  // 💥 Возвращаем ссылку на локальный объект
}

Функция возвращает ссылку на name, но как только getName() завершится, name уничтожается. Ссылка указывает в никуда.

Использование этой ссылки:

std::cout << getName() << "\n";  // UB: может напечатать мусор, может упасть

👀 Хитрость: такая ошибка часто прячется внутри более сложных функций, и ловится не сразу. Особенно в шаблонном коде или при рефакторинге.

🔒 Как безопасно?

* Возвращайте по значению, если объект небольшой или RVO (return value optimization) работает:

std::string getName() {
    std::string name = "John";
    return name;  // ок, RVO устранит копирование
}

* Или передавайте результат через параметр:

void getName(std::string& out) {
    out = "John";
}

💡 Профит: избежите UB, багов-призраков и бессонных ночей.

➡️ @cpp_geek

🧵 Сегодня покажу вам простой способ логгировать вызовы функций в C++ — пригодится для отладки и анализа кода.

Часто бывает нужно понять, какие функции вызываются, в каком порядке и с какими параметрами. Вручную вставлять std::cout — неудобно. Вместо этого используем RAII-макрос с выводом в консоль:

#include <iostream>
#include <string>

struct FunctionLogger {
    std::string func_name;
    FunctionLogger(const std::string& name) : func_name(name) {
        std::cout << ">> Entering: " << func_name << '\n';
    }
    ~FunctionLogger() {
        std::cout << "<< Exiting: " << func_name << '\n';
    }
};

#define LOG_FUNCTION() FunctionLogger logger(__FUNCTION__)

Теперь в любой функции достаточно просто написать LOG_FUNCTION();, и вы получите автоматический лог при входе и выходе:

void do_work() {
    LOG_FUNCTION();
    // Работаем...
}

Это особенно удобно в больших проектах, когда нужно быстро локализовать ошибку или понять структуру вызовов.

Можно доработать: лог в файл, потокобезопасность, включение по флагу компиляции и т.д.

➡️ @cpp_geek

Полезные функции, которые будут полезны продвинутым C++ разработчикам.

1. void assert_or_throw(bool cond, const std::string& msg)

Универсальная замена assert в runtime-среде:

void assert_or_throw(bool cond, const std::string& msg) {
    if (!cond) throw std::runtime_error(msg);
}

2. template<typename T> std::string to_string_precise(const T& val, int precision = 6)

Преобразование чисел с точностью:

template<typename T>
std::string to_string_precise(const T& val, int precision = 6) {
    std::ostringstream out;
    out << std::fixed << std::setprecision(precision) << val;
    return out.str();
}

3. template<typename F> auto scope_exit(F&& f)

RAII-функция для отложенного вызова:

template<typename F>
class ScopeExit {
    F func;
    bool active = true;
public:
    ScopeExit(F&& f) : func(std::forward<F>(f)) {}
    ~ScopeExit() { if (active) func(); }
    void dismiss() { active = false; }
};

template<typename F>
ScopeExit<F> scope_exit(F&& f) {
    return ScopeExit<F>(std::forward<F>(f));
}

4. template<typename T> constexpr bool is_power_of_two(T x)

Компилируемая проверка степени двойки:

template<typename T>
constexpr bool is_power_of_two(T x) {
    return x > 0 && (x & (x - 1)) == 0;
}

5. template<typename T> void hash_combine(std::size_t& seed, const T& val)

Для реализации собственного std::hash:

template<typename T>
void hash_combine(std::size_t& seed, const T& val) {
    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

6. std::vector<std::string> split(const std::string& str, char delimiter)

Полезна для парсинга CSV, логов и т.д.:

std::vector<std::string> split(const std::string& str, char delimiter) {
    std::vector<std::string> out;
    std::istringstream ss(str);
    std::string token;
    while (std::getline(ss, token, delimiter)) {
        out.push_back(token);
    }
    return out;
}

7. template<typename T> T clamp(T val, T min_val, T max_val)

Ручной аналог std::clamp (если нужна совместимость со старым C++):

template<typename T>
T clamp(T val, T min_val, T max_val) {
    return std::max(min_val, std::min(val, max_val));
}

8. template<typename Container, typename Predicate> bool any_of(const Container& c, Predicate pred)

Упрощённая обёртка над std::any_of:

template<typename Container, typename Predicate>
bool any_of(const Container& c, Predicate pred) {
    return std::any_of(c.begin(), c.end(), pred);
}

9. template<typename... Args> std::string format(const std::string& fmt, Args&&... args)

Интерфейс к std::format (C++20+):

template<typename... Args>
std::string format(const std::string& fmt, Args&&... args) {
    return std::vformat(fmt, std::make_format_args(args...));
}

10. template<typename T> std::string type_name()

Получение имени типа на этапе компиляции:

template<typename T>
std::string type_name() {
#ifdef __clang__
    std::string name = __PRETTY_FUNCTION__;
    return name.substr(31, name.length() - 32);
#elif defined(__GNUC__)
    std::string name = __PRETTY_FUNCTION__;
    return name.substr(49, name.length() - 50);
#elif defined(_MSC_VER)
    std::string name = __FUNCSIG__;
    return name.substr(38, name.length() - 45);
#else
    return "unknown";
#endif
}

➡️ @cpp_geek

std::thread

std::thread является частью стандартной библиотеки C++ и предоставляет возможность создания и управления потоками выполнения. Он позволяет запускать функции в отдельных потоках, обеспечивая параллельное выполнение кода.

Обратите внимание, что после создания потока std::thread, вы должны вызвать join() или detach() для корректной обработки завершения потока.

В приведенном примере мы использовали join(), чтобы основной поток дождался завершения потока t1. Если вы вызываете join() после завершения потока, программа может выдать исключение или вызвать неопределенное поведение.

➡️ @cpp_geek

Узнаем длину аудио файла

В этом примере мы открываем файл с помощью std::ifstream, находим его размер, а затем вычисляем длительность аудио файла, зная частоту дискретизации (в данном случае 44100 Гц). Выводим длительность в минутах и секундах.

Убедитесь, что заменили "your_audio_file.wav" на путь к вашему аудио файлу, а также, если частота дискретизации вашего аудио файла отличается от 44100 Гц, замените это значение на соответствующее значение вашего аудио файла.

➡️ @cpp_geek

💰Олимпиада по программированию с призовым фондом 50 000 рублей!

🏃💨Для школьников от 10 до 16 лет, задачи можно решать на языках GO, Python, JavaScript, C++

🏆Решить олимпиаду можно 23 июля (среда) с 11:00 до 19:00

🗣Регистрация закроется 20 июля в 23:55

1️⃣ место - 25 000 рублей
2️⃣ место - 15 000 рублей
3️⃣ место - 10 000 рублей

😎Регистрируйся по ссылке, участие бесплатное
Олимпиада ZamaCode

📲А также подписывайся на наш телеграм-канал, чтобы не пропустить новые олимпиады и розыгрыши!

Почему std::move может не сработать

Многие думают, что std::move всегда приводит к перемещению. Но это не так. std::move не двигает — он просто превращает объект в rvalue-ссылку. Всё остальное — за перегрузками.

Вот ловушка:

void take(std::string s) {
    // s — копия, даже если передавали std::move
}

std::string str = "hello";
take(std::move(str)); // ❌ копирование, не перемещение

Почему? Потому что take принимает по значению, а значит, всегда делает копию. Даже если ты передал std::move(str), она скопируется в s. Чтобы работало перемещение, нужна rvalue-ссылка:

void take(std::string&& s) {
    // теперь s — это rvalue-ссылка
}

Но даже тут можно облажаться:

void take(std::string&& s) {
    process(s); // ❌ снова копия!
}

void process(std::string); // по значению

Нужно снова вызвать std::move, если хочешь передать дальше как rvalue:

void take(std::string&& s) {
    process(std::move(s)); // ✅ перемещение
}

Правило: std::move — это обещание, что объект можно "украсть". Но воровать будет только та функция, которая перегружена для rvalue.

➡️ @cpp_geek

Что такое ADL и как она может вас подставить

Argument-Dependent Lookup (ADL) — это фича, которая может как упростить код, так и привести к сюрпризам.

Представьте:

namespace math {
    struct Vec {};

    void print(const Vec&) {
        std::cout << "Vec\n";
    }
}

void foo() {
    math::Vec v;
    print(v); // компилятор найдёт math::print через ADL!
}

Хотя print не в текущем скоупе, компилятор ищет её в namespace аргумента v, т.е. math. Это и есть ADL.

Звучит удобно. Но...

⚠️ Опасность:

namespace lib {
    struct Widget {};
    void process(const Widget&) {
        std::cout << "lib::process\n";
    }
}

void process(int) {
    std::cout << "global::process\n";
}

void bar() {
    lib::Widget w;
    process(w); // вызовет lib::process, а не global::process!
}

Такой вызов может внезапно потянуть неожиданные функции, особенно в generic-коде (например, в шаблонах), где ADL может найти «лишнее».

✅ Best practices:

* Не полагайся на ADL без крайней нужды.
* Используй ::qualified::names для ясности.
* В шаблонах — лучше явно передавать функции (через policy, traits, или параметры шаблона).

➡️ @cpp_geek

Зачем std::move от std::string в emplace_back?

Кажется, emplace_back(std::move(str)) — избыточно: ведь emplace_back сам конструирует объект на месте. Но с std::string и другими перемещаемыми типами всё не так просто.

Пример:

std::vector<std::string> vec;
std::string str = "hello";

vec.emplace_back(str);             // копия
vec.emplace_back(std::move(str));  // перемещение

Почему? Потому что:

> emplace_back вызывает конструктор std::string(const std::string&), если аргумент — const std::string&,
> и std::string(std::string&&), если аргумент — std::string&&.

А str — это lvalue. Даже внутри emplace_back. Без std::move, ты просишь вектор скопировать строку. С std::move — переместить.

Это относится ко всем emplace_*, когда ты передаёшь существующий объект. emplace_back("hello") — другое дело: тут создаётся временный const char*, и он уже используется для конструктора string.

👉 Правило: если аргумент — перемещаемый объект (например, std::string, std::vector), и ты передаёшь его в emplace_*, не забывай std::move. Иначе будет лишняя копия.

➡️ @cpp_geek

Move-семантика: где можно ловко сэкономить

Многие знают про std::move, но не всегда используют его там, где это реально ускоряет код. Простой пример — возврат локального объекта из функции:

#include <string>

std::string make_string() {
    std::string s = "Hello";
    return s; // RVO или move
}

С C++17 тут почти всегда RVO (Return Value Optimization). Но если RVO невозможен (например, возвращаем тернарный оператор), компилятор применит move:

std::string make_string(bool flag) {
    std::string a = "foo", b = "bar";
    return flag ? a : b; // тут будет move
}

А вот так можно подсказать компилятору явно:

return std::move(flag ? a : b);

Но осторожно: не делайте std::move для локальной переменной в простом return — это может сломать RVO и привести к лишнему перемещению.

Ещё полезно помнить: move не всегда бесплатный. Например, для std::vector он копирует указатель и размер, но не элементы. Для std::string — зависит от Small String Optimization: короткие строки перемещаются как копия.

Вывод: используйте std::move там, где явно хотите отдать объект, а не копировать. Но не злоупотребляйте им: компилятор с C++17 сам неплохо справляется.

➡️ @cpp_geek

RAII — твой лучший друг (и почему не стоит бояться умных указателей)

Старый добрый new / delete — это классика, но и источник утечек, крашей и боли. В современном C++ ручное управление памятью почти всегда антипаттерн.

Решение — RAII (Resource Acquisition Is Initialization): ресурсы живут ровно столько, сколько объект, который ими владеет. Ушёл объект из области видимости — ресурс освободился.

Пример с умными указателями:

#include <memory>
#include <iostream>

struct Foo {
    Foo() { std::cout << "Init\n"; }
    ~Foo() { std::cout << "Destroy\n"; }
};

void bar() {
    std::unique_ptr<Foo> p = std::make_unique<Foo>(); // RAII
    // делаем что-то
} // тут автоматически вызовется ~Foo()

Что важно знать:

* std::unique_ptr — владение в единственном числе, идеально для большинства случаев.
* std::shared_ptr — разделённое владение (но дороже по производительности).
* Никогда не делай new без обёртки — почти всегда лучше std::make_unique или std::make_shared.

RAII работает не только для памяти: файлы, мьютексы, сокеты — всё. Достаточно обернуть ресурс в класс с деструктором.

Профит: меньше багов, меньше утечек, чище код.

➡️ @cpp_geek

Почему std::vector<bool> — это ловушка

Если вы думаете, что std::vector<bool> — обычный вектор, только для bool, то… сюрприз! Это не совсем так.

Чтобы экономить память, стандартная библиотека делает его специализацией, хранящей биты упакованно. Цена — нетипичное поведение:

std::vector<bool> v{true, false, true};
bool* p = &v[0]; // Ошибка! Тут нет обычного bool*

Элементы vector<bool> — это не настоящие bool, а прокси-объекты. Они ведут себя как bool, но фактически это обёртки над битами. Итог:

- нельзя получить указатель на элемент;
- работа с ними медленнее, чем с bool;
- поведение иногда ломает шаблонный код, который ожидает нормальные ссылки и указатели.

Что делать?
Если вам нужна коллекция булей — берите std::vector<char> или std::vector<uint8_t>. Памяти уйдёт чуть больше, но всё будет предсказуемо и быстро.

std::vector<bool> стоит использовать только если критична экономия памяти, и вы понимаете все его подводные камни.

➡️ @cpp_geek