🍪 Как эволюционировала работа с типами в 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++ разработчика #буст

Вот оно, безопасное программирование на С++ во всей красе

🐸 Библиотека программиста

🏠 How to: Как правильно реализовать оператор присваивания

Перегрузка operator= - одна из самых коварных тем в C++. Часто приводит к багам.


🍴Правила безопасного operator=:

1️⃣ Проверяем самоприсваивание
2️⃣ Создаём временную копию
3️⃣ Используем swap idiom

class MyString {
private:
    char* data;
    size_t length;
    
public:
    // Правильный operator=
    MyString& operator=(const MyString& other) {
        if (this == &other) return *this; // самоприсваивание
        
        // Создаём временную копию
        char* temp = new char[other.length + 1];
        strcpy(temp, other.data);
        
        // Освобождаем старые данные
        delete[] data;
        
        // Присваиваем новые
        data = temp;
        length = other.length;
        
        return *this;
    }
    
    // Лучше через copy-and-swap
    MyString& operator=(MyString other) { // копия по значению
        swap(*this, other);
        return *this;
    }
};

❌ Опасность:

Без проверки самоприсваивания можем удалить данные, которые копируем.

✅ Золотое правило:

Copy-and-swap никогда не подведёт.

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