🔥 Inline static в классах — забудь про .cpp

Сколько раз ты забывал добавить определение static члена в .cpp, и компилятор радостно выдавал undefined reference?

С C++17 можно просто добавить inline к static переменной класса, и всё работает. Особенно круто это для счётчиков, кешей и паттерна Registry.

// До C++17
class Logger {
public:
    static std::ofstream log_file; // объявление
    static int message_count;       // объявление
};
// В .cpp обязательно нужны определения:
// std::ofstream Logger::log_file{"app.log"};
// int Logger::message_count = 0;

// С C++17
class Logger {
public:
    inline static std::ofstream log_file{"app.log"};
    inline static int message_count = 0;
    inline static std::mutex log_mutex;
    
    static void log(const std::string& msg) {
        std::lock_guard lock(log_mutex);
        log_file << "[" << message_count++ << "] " << msg << '\n';
    }
};
// Никаких дополнительных файлов!

❗️Теперь весь класс может жить в заголовочном файле, что идеально для template классов и header-only библиотек. Инициализация происходит при первом использовании, потокобезопасно и предсказуемо.

🐸 Рефактори свои старые классы — убери лишние .cpp файлы и наслаждайся чистым кодом.

Библиотека C/C++ разработчика

#шаблонный_код

🍴 Макросы vs Inline: битва прошлого века

В legacy коде до сих пор встречаются макросы вместо inline функций. И это проблема.

Макросы — это текстовая подстановка препроцессором до компиляции.

Классический пример:

cpp #define SQUARE(x) x*x

Выглядит невинно, но вызов SQUARE(a+b) развернется в a+b*a+b вместо (a+b)*(a+b). Проблемы с приоритетом операций, отсутствие type safety, невозможность отладки — список можно продолжать.

Inline функции решают все эти проблемы. Они проверяются компилятором на типы, поддерживают перегрузку, могут использовать пространства имен и классы. Отладчик понимает их как обычные функции. А современные компиляторы оптимизируют их так же эффективно, как макросы, но безопаснее.

Единственное преимущество макросов — работа с любыми типами без шаблонов. Но с появлением constexpr и шаблонов в C++11/14/17 даже это преимущество исчезло.

Вы всё ещё пишете макросы для "быстрых" функций или давно перешли на inline/constexpr?

Библиотека C/C++ разработчика

#междусобойчик

🍴 Типичные ошибки со structured bindings

Structured bindings выглядят просто, но есть подводные камни, которые ловят даже опытные разработчики.


1️⃣ Забыли & и получили копию

struct Heavy {
    std::vector<int> data{1'000'000};
};

std::pair<int, Heavy> getPair();

// ❌ Копирование элементов!
auto [id, heavy] = getPair();

// ✅ Работа через ссылку
auto& [id, heavy] = getPair();

2️⃣ Неправильное количество переменных

std::tuple<int, int, int> getCoords();

// ❌ Ошибка компиляции
auto [x, y] = getCoords();  // Нужно ровно 3 переменные!

// ✅ Правильно
auto [x, y, z] = getCoords();

3️⃣ Dangling references

// ❌ ОПАСНО!
const auto& [x, y] = std::make_pair(1, 2);
// Временный объект уничтожен, x и y невалидны

// ✅ БЕЗОПАСНО
auto [x, y] = std::make_pair(1, 2);

4️⃣ Попытка модифицировать const

const auto [x, y] = getPair();
x = 10;  // ❌ Ошибка: x — константа!

// Нужно:
auto [x, y] = getPair();  // Без const

5️⃣ Неправильные ожидания от типов

std::map<int, std::string> m{{1, "one"}};

// key имеет тип const int&, не int&!
for (auto& [key, value] : m) {
    key = 2;  // ❌ Ошибка компиляции!
}

✏️ Какие ошибки совершали вы? Поделитесь в комментариях!

🔹 Курс «Алгоритмы и структуры данных»
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

Библиотека C/C++ разработчика

#константная_правильность

🍪 Как zip итерирует несколько ranges одновременно без накладных расходов?

Параллельная итерация по нескольким последовательностям — паттерн из Python. В C++ до C++23 это требовало индексов или связывания итераторов руками. views::zip делает это zero-cost абстракцией.


✅ Tuple итераторов

Под капотом zip хранит tuple из итераторов каждого range. При ++it инкрементирует все одновременно:

std::vector<int> ids = {1, 2, 3};
std::vector<string> names = {"Alice", "Bob", "Charlie"};

for (auto [id, name] : views::zip(ids, names)) {
    // id и name — это references, не копии
    std::print("{}: {}\n", id, name);
}

💡 Structured binding магия

auto [id, name] — это structured binding поверх tuple<int&, string&>. Компилятор разворачивает это в прямой доступ к памяти, никаких промежуточных объектов:

// Что реально происходит
auto&& __pair = *it;  // tuple<int&, string&>
int& id = get<0>(__pair);
string& name = get<1>(__pair);

🍬 Остановка на кратчайшем

zip заканчивается когда любой из ranges закончился. Это безопасно — не будет out-of-bounds:

vector<int> short_vec = {1, 2};
vector<int> long_vec = {10, 20, 30, 40};
auto z = views::zip(short_vec, long_vec);  // Только 2 элемента

Практика: Используй вместо индексного доступа [i] когда нужно синхронно пройти несколько контейнеров. Компилятор оптимизирует до прямых указателей, часто быстрее индексов.


🔹 Курс «Алгоритмы и структуры данных»
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

Библиотека C/C++ разработчика

#под_капотом