Что интересного нашли в новых стандартах С++17, С++20?cplus-35

Последние стандарты C++ принесли множество значимых улучшений. Вот ключевые фичи, которые изменили мой подход к разработке:

C++17: эволюция языка

1. Structured Bindings

Что дает: Упрощает работу с кортежами и структурами

std::map<int, std::string> m = {{1, "one"}, {2, "two"}};
for (const auto& [key, value] : m) {  // Автоматическая декомпозиция
    std::cout << key << ": " << value << '\n';
}

2. std::optional

Зачем: Явное представление опциональных значений вместо nullptr или "волшебных чисел"

std::optional<int> findItem(const std::vector<int>& v, int target) {
    auto it = std::find(v.begin(), v.end(), target);
    if (it != v.end()) return *it;
    return std::nullopt;
}

3. std::variant и std::visit

Польза: Типобезопасный union + pattern matching

std::variant<int, float, std::string> v;
v = 3.14f;
std::visit([](auto&& arg) {  // Обработка всех типов
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg;
    } else if constexpr (std::is_same_v<T, float>) {
        std::cout << "float: " << arg;
    }
}, v);

4. Параллельные алгоритмы STL

Производительность: Запуск алгоритмов на нескольких ядрах

std::vector<int> v = {...};
std::sort(std::execution::par, v.begin(), v.end());  // Параллельная сортировка

C++20: революционные изменения

1. Concepts

Преимущества: Ограничения шаблонов с понятными ошибками компиляции

template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template <Numeric T>  // Явное ограничение
T square(T x) { return x * x; }

2. Ranges

Удобство: Композиция алгоритмов без итераторов

#include <ranges>
namespace views = std::views;

auto even = [](int i) { return i % 2 == 0; };
auto square = [](int i) { return i * i; };

for (int i : std::views::iota(1) 
              | views::filter(even)
              | views::transform(square)
              | views::take(10)) {
    std::cout << i << ' ';  // 4 16 36 64 100 144 196 256 324 400
}

3. Coroutines

Применение: Асинхронный код без callback hell

#include <coroutine>
generator<int> range(int start, int end) {
    for (int i = start; i < end; ++i)
        co_yield i;  // Приостановка и возобновление
}

for (int i : range(1, 10)) {
    std::cout << i << ' ';  // 1 2 3 ... 9
}

4. std::format

Улучшение: Современная замена printf и строковых потоков

std::cout << std::format("Hello, {}! The answer is {:.2f}\n", "world", 3.14159);
// Hello, world! The answer is 3.14

5. Three-way comparison

Синтаксис: Упрощение операторов сравнения

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;  // Генерация всех сравнений
};

Сравнение стандартов

ФичаC++17C++20
Concepts❌✅
Ranges❌✅
Structured Bindings✅➕
Coroutines❌✅
Параллельные алгоритмы✅➕

➕ - улучшено в C++20

Резюмируем

  1. C++17 сделал код:

    • Более безопасным (optional, variant)
    • Более выразительным (structured bindings)
    • Более производительным (параллельные алгоритмы)

  2. C++20 принес:

    • Концептуально новый подход к шаблонам (concepts)
    • Функциональный стиль работы с данными (ranges)
    • Нативную поддержку асинхронности (coroutines)

Эти стандарты изменили идиоматику C++, приблизив язык к современным парадигмам разработки без потери производительности.

Вопросы

Собеседования