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

🐸 Оптимизация копирования с помощью техники Zero-Copy


🔥 Проблема:

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


✏️ Решение:

Zero-Copy позволяет передавать данные без копирования в пользовательское пространство, используя системные вызовы sendfile() и splice() в Linux.

#include <sys/sendfile.h>
#include <fcntl.h>

// Отправка файла через сокет без копирования в userspace
int send_file_zerocopy(int socket_fd, const char* filename) {
    int file_fd = open(filename, O_RDONLY);
    off_t offset = 0;
    struct stat file_stat;
    
    fstat(file_fd, &file_stat);
    // Прямая передача из ядра в сокет
    ssize_t sent = sendfile(socket_fd, file_fd, &offset, file_stat.st_size);
    
    close(file_fd);
    return sent;
}

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

• Снижение использования CPU при передаче данных
• Уменьшение задержек за счет исключения системных вызовов copy
• Экономия памяти — данные не загружаются в пользовательское пространство
• Масштабируемость для высоконагруженных веб-серверов и прокси


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

#буст

🍿 How to: Structured Bindings: распаковка данных (C++17)

Элегантная работа с multiple return values и сложными структурами.

#include <map>
#include <tuple>
#include <array>

// Функция возвращает несколько значений
std::tuple<int, std::string, double> get_data() {
    return {42, "hello", 3.14};
}

struct Point { int x, y; };

int main() {
    // 1. Распаковка tuple
    auto [id, name, price] = get_data();
    std::cout << id << " " << name << " " << price << "\n";
    
    // 2. Распаковка struct
    Point p{10, 20};
    auto [x, y] = p;
    std::cout << "Point: " << x << ", " << y << "\n";
    
    // 3. Распаковка array
    std::array<int, 3> arr{1, 2, 3};
    auto [first, second, third] = arr;
    
    // 4. Распаковка map::insert результата
    std::map<std::string, int> m;
    auto [iterator, inserted] = m.insert({"key", 42});
    if (inserted) {
        std::cout << "Inserted: " << iterator->first << "\n";
    }
    
    // 5. Итерация по map с распаковкой
    for (const auto& [key, value] : m) {
        std::cout << key << " -> " << value << "\n";
    }
    
    // 6. Распаковка с модификаторами
    auto& [rx, ry] = p;  // Ссылки на члены
    rx = 100;           // Изменяем оригинал
}

💡 Применения:

Более читаемый код при работе с парами, tuple, структурами


✏️ А как вы распаковываете данные? Пишите в комментариях.

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

#буст