🍩 C++ Concepts — типобезопасность на новом уровне


‼️ Проблема:

В шаблонах C++ ошибки типов приводят к критическим сообщениям компилятора на десятки строк. Отладка становится кошмаром, особенно для новичков в команде.


✅ Решение:

C++ Concepts позволяют явно указать требования к типам шаблонов. Это делает код самодокументируемым и дает понятные сообщения об ошибках.


✏️ Пример кода:

#include <concepts>

// Определяем концепт для числовых типов
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// Функция принимает только числовые типы
template<Numeric T>
T multiply(T a, T b) {
    return a * b;
}

int main() {
    auto result1 = multiply(5, 10);        // OK: int
    auto result2 = multiply(3.14, 2.0);    // OK: double
    // auto result3 = multiply("hello", "world"); // Ошибка компиляции с понятным сообщением
    return 0;
}

🌳 Преимущества:

• Понятные сообщения об ошибках компиляции
• Самодокументируемый код с явными требованиями к типам
• Улучшенная производительность компиляции за счет раннего отсева неподходящих типов
• Возможность перегрузки функций на основе концептов

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

📦 Создание модулей C++20 для быстрой компиляции

Modules — это будущее организации C++ кода.


❗️ Проблема:

Медленная компиляция из-за #include файлов.


✅ Решение:

1️⃣ Создайте module interface файл
2️⃣ Экспортируйте нужные декларации
3️⃣ Импортируйте модуль в коде

// math_utils.ixx
export module math_utils;

export namespace math {
    int add(int a, int b) {
        return a + b;
    }
    
    double sqrt_approx(double x) {
        return x / 2.0; // Упрощенная версия
    }
}

// main.cpp
import math_utils;
#include <iostream>

int main() {
    std::cout << math::add(3, 4) << std::endl;
    return 0;
}

❌ Частые ошибки:

Забывать ключевое слово export для публичных функций.


💡 Совет:

Modules работают не во всех компиляторах — проверяйте поддержку!

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

✅ How to: Создание собственного итератора для контейнера

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

Проблема: Нужно создать контейнер, работающий с range-based for и STL.


✏️ Решение:

1️⃣ Реализуйте iterator traits
2️⃣ Определите begin() и end()
3️⃣ Поддержите const итераторы

#include <iterator>
#include <algorithm>
#include <iostream>

template<typename T>
class CircularBuffer {
    T* data;
    size_t capacity_;
    size_t size_;
    size_t head_ = 0;
    
public:
    explicit CircularBuffer(size_t capacity) 
        : data(new T[capacity]), capacity_(capacity), size_(0) {}
    
    ~CircularBuffer() { delete[] data; }
    
    // Iterator class
    class iterator {
        T* ptr;
        size_t capacity;
        size_t index;
        
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        
        iterator(T* ptr, size_t capacity, size_t index)
            : ptr(ptr), capacity(capacity), index(index) {}
        
        reference operator*() { return ptr[index % capacity]; }
        pointer operator->() { return &ptr[index % capacity]; }
        
        iterator& operator++() {
            ++index;
            return *this;
        }
        
        iterator operator++(int) {
            iterator tmp = *this;
            ++index;
            return tmp;
        }
        
        bool operator==(const iterator& other) const {
            return index == other.index;
        }
        
        bool operator!=(const iterator& other) const {
            return !(*this == other);
        }
    };
    
    void push(const T& item) {
        data[(head_ + size_) % capacity_] = item;
        if (size_ < capacity_) {
            ++size_;
        } else {
            ++head_;
            head_ %= capacity_;
        }
    }
    
    iterator begin() { return iterator(data, capacity_, head_); }
    iterator end() { return iterator(data, capacity_, head_ + size_); }
    
    size_t size() const { return size_; }
    bool empty() const { return size_ == 0; }
};

int main() {
    CircularBuffer<int> buffer(5);
    
    // Заполняем буфер
    for (int i = 1; i <= 7; ++i) {
        buffer.push(i);
    }
    
    // Range-based for работает!
    for (const auto& item : buffer) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
    
    // STL алгоритмы работают!
    auto it = std::find(buffer.begin(), buffer.end(), 5);
    if (it != buffer.end()) {
        std::cout << "Found: " << *it << std::endl;
    }
}

Частые ошибки: Не реализовать все необходимые operator для итератора.

💡 Совет: Правильные итераторы делают ваш контейнер first-class citizen в ST.

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

🚀 std::unreachable в C++23

Компилятор не всегда понимает, что некоторые участки кода недостижимы. std::unreachable() помогает ему генерировать более оптимальный код.


📋 Пошаговое решение:

1️⃣ Подключите заголовок

#include <utility>  // C++23

2️⃣ Используйте в switch без default

enum class Color { RED, GREEN, BLUE };

std::string colorToString(Color c) {
    switch(c) {
        case Color::RED:   return "red";
        case Color::GREEN: return "green"; 
        case Color::BLUE:  return "blue";
    }
    std::unreachable(); // Говорим компилятору: сюда не попадём!
}

3️⃣ Применяйте в условных блоках

int divide(int a, int b) {
    if (b != 0) {
        return a / b;
    }
    
    // Логически сюда не должны попасть
    handleError(); // Наша обработка
    std::unreachable(); // Оптимизация для компилятора
}

⚠️ Частые ошибки:

❌ Неправильно: Использовать когда код действительно достижим
❌ Неправильно: Забывать про обработку ошибок перед unreachable()
✅ Правильно: Использовать только когда логически уверены в недостижимости


🎯 Практический совет:

std::unreachable() - это контракт с компилятором. Если код всё-таки достигнет этой точки, поведение неопределено. Используйте только когда на 100% уверены.


🎯 Альтернатива:

В старых стандартах используйте __builtin_unreachable() (GCC/Clang) или __assume(false) (MSVC).

🐸Библиотека C/C++ разработчика #буст

✏️ Промпт дня: Создание юнит-тестов для надёжного кода

Юнит-тесты — это автоматизированные тесты, которые проверяют поведение отдельных частей кода в изоляции. Они помогают обнаруживать ошибки на ранней стадии и значительно упрощают поддержку кода в C++.


☀️ Решение с помощью AI

Please write unit tests for [имя файла и модуля] to ensure its proper functioning

[ВСТАВЬТЕ ВАШ КОД ЗДЕСЬ]

🧋 Пример трансформации

До:

class Calculator {
public:
    int add(int a, int b) { return a + b; }
    int divide(int a, int b) { 
        if (b == 0) throw std::invalid_argument("Division by zero");
        return a / b; 
    }
};

После:

#include <gtest/gtest.h>

TEST(CalculatorTest, AddPositiveNumbers) {
    Calculator calc;
    EXPECT_EQ(calc.add(2, 3), 5);
}

TEST(CalculatorTest, DivideByZero) {
    Calculator calc;
    EXPECT_THROW(calc.divide(10, 0), std::invalid_argument);
}

TEST(CalculatorTest, DivideNormalCase) {
    Calculator calc;
    EXPECT_EQ(calc.divide(10, 2), 5);
}

✏️ Как часто вы пишете юнит-тесты для своего C++ кода?


🐸Библиотека C/C++ разработчика #буст

🌲 Концепты в C++

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


✏️ Создание концепта:

1️⃣ Определите требования к типу
2️⃣ Проверьте наличие методов
3️⃣ Используйте в шаблонах

#include <concepts>
#include <iostream>
#include <string>
#include <sstream>

// Концепт для сериализуемых типов
template<typename T>
concept Serializable = requires(T obj, std::ostream& os, std::istream& is) {
    { obj.serialize(os) } -> std::same_as<void>;
    { T::deserialize(is) } -> std::same_as<T>;
};

// Пример сериализуемого класса
struct Person {
    std::string name;
    int age;
    
    void serialize(std::ostream& os) const {
        os << name << " " << age;
    }
    
    static Person deserialize(std::istream& is) {
        Person p;
        is >> p.name >> p.age;
        return p;
    }
};

// Функция для работы с сериализуемыми объектами
template<Serializable T>
void save_and_load(const T& obj) {
    std::stringstream ss;
    
    // Сериализация
    obj.serialize(ss);
    std::cout << "Serialized: " << ss.str() << std::endl;
    
    // Десериализация
    T loaded = T::deserialize(ss);
    std::cout << "Deserialized successfully" << std::endl;
}

// Использование
void example() {
    Person p{"Alice", 25};
    save_and_load(p);  // ✅ Работает
    
    // save_and_load(42);  // ❌ Ошибка компиляции
}

😡 Частые ошибки:

❌ Забывают про static методы в концептах
❌ Не учитывают const-correctness
❌ Создают слишком жёсткие требования


⛄️ Практический совет:

✅Концепты помогают создавать self-documenting API и ловить ошибки на этапе компиляции.

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

🍪 Как эволюционировала работа с типами в C++: от C++98 до C++23

🌳 Помните времена, когда приходилось писать std::vector<std::vector<int> > с пробелом? Давайте посмотрим, как изменилась работа с типами за 25 лет!


✏️ Пошаговая эволюция:

1️⃣ C++98 - Боль и страдания

//Verbosity nightmare
std::vector<std::pair<std::string, int> > vec; // пробел обязателен!
for (std::vector<std::pair<std::string, int> >::iterator it = vec.begin(); 
     it != vec.end(); ++it) {
    // работаем с *it
}

2️⃣ C++11 - Первые облегчения

// auto и range-based for
std::vector<std::pair<std::string, int>> vec; // >> теперь OK!
for (auto& item : vec) {
    // намного чище!
}

3️⃣ C++17 - Магия template argument deduction

// Не нужно указывать типы
std::vector vec{std::pair{"hello", 42}, {"world", 24}}; // CTAD!
std::optional opt = some_function(); // тип выводится автоматически

// Structured bindings
for (auto [name, value] : vec) {
    std::cout << name << ": " << value << "\n";
}

4️⃣ C++20 - Concepts и constraints

#include <concepts>

template<std::integral T>  // Концепты!
auto process(T value) {
    return value * 2;
}

// Abbreviated function templates
auto add(std::integral auto a, std::integral auto b) {
    return a + b;
}

5️⃣ C++23 - Еще больше удобства

// if consteval для compile-time проверок
constexpr auto get_value() {
    if consteval {
        return 42; // compile-time версия
    } else {
        return expensive_runtime_calc(); // runtime версия  
    }
}

// Multidimensional subscript operator
matrix[1, 2, 3] = value; // вместо matrix[1][2][3]

💔 Частые ошибки:

❌ Злоупотребление auto: auto x = 5u; может быть неочевидным
✅ Явные типы для API: std::uint32_t count = get_count();

❌ Игнорирование concepts: старые template error messages
✅ Используйте standard concepts: std::integral, std::floating_point

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

😈 Modules в C++20 - будущее или очередной провал?

Modules обещали революцию, а получили головную боль!

5 лет назад: "Modules решат все проблемы! Быстрая компиляция! Настоящая инкапсуляция!"

2025 год: Поддержка модулей все еще экспериментальная, build системы путаются, а простой hello world на модулях собирается в 3 раза дольше классического 😅


🐊 Реальность модулей:

- CMake = beta поддержка
- Legacy код = не портируется
- Compile times = пока что хуже


😡 Парадокс:

Хотели ускорить компиляцию, получили новые проблемы с build системами.
Но справедливости ради - концепция правильная. Проблема в том, что экосистема не готова. Может через 5 лет будет по-другому?


💡Сравнение:

// Классика: работает везде
#include <iostream>
#include "my_header.h"

// Modules: работает... иногда... если повезет
import std.io;  
import my.module;

❓Вопрос:

Стоит ли уже сейчас изучать modules или подождать еще пару лет?

🔥 Уже использую в пет проектах
⚡️ Изучаю, но не применяю
👾 Жду стабилизации
❤️ Пока что #include рулит

Библиотека C/C++ разработчика #междусабойчик

✏️ conjure_enum: легковесное перечисление C++20


🔹 Зачем?

Работа с перечислениями (enum) в C++ часто требует дополнительного кода: преобразование в строку, проверка значений, итерация по всем вариантам. Библиотека conjure_enum автоматизирует эту рутину!


🔹 Что умеет?

✅ Генерация to_string() для enum
✅ Проверка валидности значений (is_valid)
✅ Итерация по всем элементам enum
✅ Поддержка enum и enum class
✅ Минимальный оверхед (всё вычисляется на этапе компиляции)


🔹 Пример использования:

#include "conjure_enum.h"

CONJURE_DEFINE_ENUM(Color, Red, Green, Blue)

int main() {
    Color c = Color::Green;
    std::cout << conjure_enum::to_string(c); // "Green"
    std::cout << conjure_enum::is_valid(42); // false
    for (Color value : conjure_enum::values<Color>()) { ... }
}

🔹 Плюсы:

✔️ Заголовочный-only (просто подключи conjure_enum.h)
✔️ Не требует C++20 (работает даже на C++11)
✔️ Лёгкая интеграция в существующий код


💡 Кому пригодится?

— Тем, кто устал писать switch-case для enum-ов
— Если нужна удобная отладка (вывод значений в лог)
— Для валидации конфигов/сетевых данных

🔗 Ссылка

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