Что интересного нашли в новых стандартах С++17, С++20 (конкретные фичи)?cplus-72

C++17: Главные улучшения

1. Structured Bindings

   • Позволяет разбирать кортежи и структуры в отдельные переменные:

   auto [iter, inserted] = my_map.insert({"key", 42});
   if (inserted) { /* ... */ }
   

   • Польза: Упрощает работу с std::pair, std::tuple и пользовательскими типами.

2. std::optional

   • Явное выражение "nullable" значений без nullptr/специальных флагов:

   std::optional<int> parse_int(const std::string& s) {
       if (s.empty()) return std::nullopt;
       return std::stoi(s);
   }
   

   • Польза: Безопасная замена -1 или nullptr для обозначения отсутствия значения.

3. std::variant и std::visit

   • Типобезопасный union + паттерн-матчинг:

   std::variant<int, float, std::string> v = 3.14f;
   std::visit([](auto&& arg) {
       using T = std::decay_t<decltype(arg)>;
       if constexpr (std::is_same_v<T, float>) { /* ... */ }
   }, v);
   

   • Польза: Альтернатива динамическому полиморфизму без накладных расходов.

4. if constexpr

   • Условная компиляция в шаблонах:

   template<typename T>
   auto serialize(const T& t) {
       if constexpr (std::is_arithmetic_v<T>) {
           return std::to_string(t);
       } else {
           return t.serialize();
       }
   }
   

   • Польза: Замена SFINAE в многих сценариях.

C++20: Прорывные изменения

1. Concepts

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

   template<typename T>
   concept Addable = requires(T a, T b) { { a + b } -> std::same_as<T>; };
   
   template<Addable T>
   T sum(T a, T b) { return a + b; }
   

   • Польза: Читаемые ошибки компиляции и явные требования к типам.

2. Ranges

   • Алгоритмы с "ленивыми" операциями и pipe-стилем:

   auto even_squares = views::iota(1) 
                     | views::transform([](int x){ return x*x; })
                     | views::filter([](int x){ return x % 2 == 0; })
                     | views::take(10);
   

   • Польза: Упрощение цепочек обработки данных (как в LINQ/Stream API).

3. Coroutines

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

   generator<int> range(int start, int end) {
       for (int i = start; i < end; ++i)
           co_yield i;
   }
   

   • Польза: Фундамент для async/await-подобных сценариев.

4. std::format

   • Современная замена printf и stringstream:

   std::string message = std::format("Hello, {}! The answer is {}.", name, 42);
   

   • Польза: Безопасный, расширяемый и локализуемый вывод.

5. constexpr improvements

   • Виртуальные функции, try-catch, аллокация памяти в compile-time:

   constexpr std::vector<int> build_vector() {
       std::vector<int> v = {1, 2, 3};
       v.push_back(4);
       return v;
   }
   

   • Польза: Метапрограммирование становится ближе к "обычному" коду.

Резюмируем

• C++17: Фокус на удобстве (optional, variant, structured bindings) и метапрограммировании (if constexpr).
• C++20: Революционные изменения — концепты (более строгий шаблонный код), корутины (асинхронность) и ranges (функциональный стиль).
  Эти стандарты делают C++ выразительнее, сохраняя производительность. Однако сложность языка растет, и не все фичи пока хорошо поддерживаются компиляторами (особенно C++20).