C++ в XXI веке - Эволюция языка и взгляд Бьярне Страуструпа

import std;                  // подключаем всю стандартную библиотеку
using namespace std;
 
int main()                   // печатаем уникальные строки из ввода
{
        unordered_map<string,int> m;  // хеш-таблица
        for (string line; getline(cin,line); )
                if (m[line]++ == 0)
                        cout << line << '\n';
}

import std;                               
using namespace std;         // подключаем всю стандартную библиотеку
vector<string> collect_lines(istream& is) // собираем уникальные строки из ввода
{
        unordered_set s;               // хеш-таблица
        for (string line; getline(is,line); )
            s.insert(line);
        return vector{from_range, s};  // копируем элементы множества в вектор
}
auto lines = collect_lines(cin);

auto calculate_values(const vector<int>& data) {
    vector<double> results;
    auto transformer = [factor = 1.5](int value) { return value * factor; };
    
    for (auto value : data) {
        results.push_back(transformer(value));
    }
    
    return results;  // Автоматически использует перемещение, а не копирование
}

void legacy_approach() {
    Resource* res = new Resource();  // Необходимо явно освободить
    try {
        res->use();
        // Если здесь возникнет исключение, произойдёт утечка памяти
    }
    catch (...) {
        delete res;  // Необходимо не забыть удалить ресурс
        throw;
    }
    delete res;  // Снова не забываем удалить
}
 
void modern_approach() {
    auto res = make_unique<Resource>();  // Автоматически освободится
    res->use();  // Даже при исключении память будет освобождена
}

  std::map<string, int> m;
  // ...
  for (const auto& [key, value] : m) {
      cout << key << ": " << value << '\n';
  }

  if (auto it = map.find(key); it != map.end()) {
      use(it->second);
  }

template<typename T>
concept Sortable = std::ranges::random_access_range<T> && 
                   requires(std::iter_value_t<T> a, std::iter_value_t<T> b) {
                       { a < b } -> std::convertible_to<bool>;
                   };
 
void sort(Sortable auto& container) {
    // Реализация сортировки
}

auto results = data 
    | std::views::filter([](int n) { return n % 2 == 0; })  // Только чётные
    | std::views::transform([](int n) { return n * n; })   // Возвести в квадрат
    | std::views::take(10);                               // Взять первые 10

task<string> fetch_data(string url) {
    auto response = co_await http_client.get(url);
    if (!response.ok())
        co_return "Error: " + response.status_code();
    co_return response.text();
}
 
task<void> process() {
    try {
        auto data = co_await fetch_data("https://example.com/api");
        display(data);
    } catch (const exception& e) {
        show_error(e.what());
    }
}

export module map_printer;   // определяем модуль
import iostream;             // импортируем модули для реализации
import containers;
using namespace std;
 
export   // этот шаблон — единственная экспортируемая сущность
template<Sequence S>
void print_map(const S& m) {
    for (const auto& [key,val] : m)   // доступ к паре ключ-значение из m
        cout << key << " -> " << val << '
';
}

#include <libgalil/DmcDevice.h> // 457440 строк после препроцессинга
int main() {                     // 151268 непустых строк
    Libgalil::DmcDevice("192.168.55.10"); // 1546 миллисекунд на компиляцию
}

import libgalil;              // 5 строк после препроцессинга
 
int main() {                  // 4 непустых строки
    Libgalil::DmcDevice("192.168.55.10"); // 62 миллисекунды на компиляцию
}

template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
 
template<Arithmetic T>
T square(T value) {
    return value * value;
}
 
square(42);    // OK
square("text"); // Ошибка: "text" не удовлетворяет концепту Arithmetic

template<typename R>
concept Sortable_range =
    random_access_range<R> &&      // имеет begin()/end(), ++, [], +, …
    sortable<iterator_t<R>>;       // можно сравнивать и менять местами элементы

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n-1);
}
 
consteval auto get_compile_time_value() {
    return factorial(5);  // Вычисляется на этапе компиляции
}
 
constinit int global = get_compile_time_value();  // Инициализируется на этапе компиляции

std::expected<User, Error> find_user(UserId id) {
    if (id < 0)
        return std::unexpected(Error::InvalidId);
    
    auto user = database.lookup(id);
    if (!user)
        return std::unexpected(Error::UserNotFound);
    
    return user;
}
 
// Использование
auto result = find_user(user_id);
if (result)
    process_user(*result);
else
    handle_error(result.error());

// Пример использования современной стандартной библиотеки
std::vector<int> data = {1, 2, 3, 4, 5};
auto sum = std::accumulate(data.begin(), data.end(), 0);
auto product = std::reduce(data.begin(), data.end(), 1, std::multiplies<>{});
 
// В C++20 с диапазонами:
auto sum2 = std::ranges::fold_left(data, 0, std::plus<>{});

// Сложный низкоуровневый C++
void* raw_memory = operator new(sizeof(SomeType) * N);
SomeType* arr = static_cast<SomeType*>(raw_memory);
for (size_t i = 0; i < N; ++i)
    new(&arr[i]) SomeType(args...);
// ...
for (size_t i = N; i > 0; --i)
    arr[i-1].~SomeType();
operator delete(raw_memory);
 
// Современный высокоуровневый C++
std::vector<SomeType> arr(N, SomeType(args...));
// Автоматически освобождает память и вызывает деструкторы

// Инициализация с фигурными скобками работает с любыми типами
int a{42};
std::vector<int> v{1, 2, 3};
struct Point { int x, y; };
Point p{10, 20};
auto [first, second] = std::pair{1, "text"};

class File {
    FILE* handle;
public:
    File(const char* filename, const char* mode) : handle(fopen(filename, mode)) {
        if (!handle) throw std::runtime_error("Failed to open file");
    }
    ~File() { if (handle) fclose(handle); }
    // Запрещаем копирование
    File(const File&) = delete;
    File& operator=(const File&) = delete;
    // Операции с файлом...
};
 
void process_file() {
    File f("data.txt", "r");  // Открыть файл
    // Работа с файлом...
    // При выходе из области видимости файл автоматически закроется
}

// Старый стиль с ручным управлением памятью
char* old_concatenate(const char* s1, const char* s2) {
    size_t len1 = strlen(s1);
    size_t len2 = strlen(s2);
    char* result = new char[len1 + len2 + 1];
    strcpy(result, s1);
    strcat(result, s2);
    return result;
    // Возвращает указатель, который нужно освободить вручную
}
 
// Современный стиль
string concatenate(string_view s1, string_view s2) {
    string result;
    result.reserve(s1.size() + s2.size());
    result += s1;
    result += s2;
    return result;
    // Память управляется автоматически
}

vector<string> process_data(vector<string>&& data) {
    // Обработка данных
    sort(data.begin(), data.end());
    // Возврат обработанных данных
    return data;  // Перемещение, а не копирование
}
 
auto result = process_data(std::move(input_data));

// Пример высокопроизводительного кода для научных вычислений с использованием SIMD
#include <immintrin.h>
 
void vector_add_avx(const float* a, const float* b, float* c, size_t n) {
    for (size_t i = 0; i < n; i += 8) {
        __m256 va = _mm256_loadu_ps(a + i);
        __m256 vb = _mm256_loadu_ps(b + i);
        __m256 result = _mm256_add_ps(va, vb);
        _mm256_storeu_ps(c + i, result);
    }
}

// Вычисление факториала во время компиляции в C++20
constexpr int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}
 
// Использование
constexpr int result = factorial(10);  // Вычисляется на этапе компиляции

template<typename T>
concept Numeric = std::is_arithmetic_v<T>;
 
template<Numeric T>
T square(T value) {
    return value * value;
}
 
// Специализация для матриц
template<typename T>
requires Matrix<T>
T square(const T& matrix) {
    return matrix * matrix;  // Матричное умножение
}

cmake_minimum_required(VERSION 3.20)
project(ModernCppProject VERSION 1.0)
 
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
# Импорт библиотеки с использованием vcpkg
find_package(fmt CONFIG REQUIRED)
 
add_executable(MyApp main.cpp)
target_link_libraries(MyApp PRIVATE fmt::fmt)

// math.cppm - модуль
export module math;
 
export int add(int a, int b) { return a + b; }
export int subtract(int a, int b) { return a - b; }
 
// main.cpp - использование
import math;
 
int main() {
    return add(5, subtract(10, 7));
}

# В CMake
target_precompile_headers(MyApp PRIVATE
    <vector>
    <string>
    <unordered_map>
)

// Кросс-платформенная работа с файловой системой (C++17)
#include <filesystem>
namespace fs = std::filesystem;
 
void process_directory(const fs::path& dir) {
  for (const auto& entry : fs::directory_iterator(dir)) {
    if (entry.is_regular_file()) {
      fs::path filepath = entry.path();
      std::cout << filepath.filename() << std::endl;
    }
  }
}

#include <memory_resource>
#include <vector>
 
// Создаём буфер на стеке
std::array<std::byte, 4096> buffer;
 
// Создаём аллокатор, использующий наш буфер
std::pmr::monotonic_buffer_resource pool{buffer.data(), buffer.size()};
 
// Создаём вектор, использующий этот аллокатор
std::pmr::vector<int> v{&pool};
 
// Заполняем вектор — память выделяется из нашего буфера
for (int i = 0; i < 100; ++i) {
    v.push_back(i);
}

#include <pybind11/pybind11.h>
namespace py = pybind11;
 
int add(int a, int b) {
    return a + b;
}
 
PYBIND11_MODULE(example, m) {
    m.doc() = "pybind11 example plugin";
    m.def("add", &add, "A function that adds two numbers");
}

// Предполагаемый вид API для асинхронных операций в C++26
auto result = std::execution::schedule(my_scheduler)
              | std::execution::then([](auto& ctx) {
                  return expensive_computation();
                })
              | std::execution::then([](auto result) {
                  return process_result(std::move(result));
                });

// Предполагаемый синтаксис для рефлексии
constexpr auto members = std::meta::members_of(reflexpr(MyClass));
for (constexpr auto member : members) {
    constexpr std::string_view name = std::meta::name_of(member);
    // Генерация кода на основе информации о членах класса
}

// Предполагаемый API для SIMD в будущих стандартах
std::simd<float, 8> a = load_aligned(float_ptr);
std::simd<float, 8> b = load_aligned(float_ptr + 8);
store_aligned(result_ptr, a * b + std::simd<float, 8>(1.0f));

double sqrt(double x)
  [[expects: x >= 0]]  // Предусловие
  [[ensures r: r >= 0 && abs(r*r - x) < epsilon]];  // Постусловие

inspect (value) {
  is int i => handle_int(i);
  is string s => handle_string(s);
  is [a, b, ...rest] => handle_array(a, b, rest);
  _ => handle_default();
}

auto distance = 5.0 * si::meter;
auto time = 2.0 * si::second;
auto velocity = distance / time;  // type: si::meter_per_second

std::expected<int, ErrorCode> divide(int a, int b) {
    if (b == 0)
        return std::unexpected(ErrorCode::DivisionByZero);
    return a / b;
}
 
// Использование
auto result = divide(10, 2);
if (result) {
    std::cout << "Результат: " << *result << '\n';
} else {
    std::cout << "Ошибка: " << static_cast<int>(result.error()) << '\n';
}

// legacy.h
#ifndef LEGACY_H
#define LEGACY_H
// Традиционный заголовочный файл
#endif
 
// legacy.cppm
module;
#include "legacy.h" // Включение традиционного заголовка
export module legacy; // Экспортируем как модуль

[[profile::enforce(type)]] // Запрет неявных преобразований и неинициализированных объектов
void safe_function() {
    // Здесь разрешены только безопасные с точки зрения типов операции
}

void print_fields(auto obj) {
    constexpr auto members = std::meta::get_data_members<decltype(obj)>();
    std::meta::for_each<members>([&](auto member) {
        std::cout << std::meta::get_name(member) << ": " 
                 << obj.*member << '\n';
    });
}

std::variant<int, std::string, std::vector<int>> v = get_data();
 
match(v) {
    pattern<int> i: std::cout << "Int: " << i << '\n';
    pattern<std::string> s: std::cout << "String: " << s << '\n';
    pattern<std::vector<int>> vec: {
        std::cout << "Vector of size " << vec.size() << '\n';
        for (int x : vec) std::cout << x << ' ';
    }
}

notify_queue<int> queue;
 
// Производитель
void producer() {
    for (int i = 0; i < 100; ++i) {
        queue.push(i);
        // Автоматически уведомляет потребителей
    }
}
 
// Потребитель
void consumer() {
    while (auto value = queue.try_pop()) {
        process(*value);
    }
}

task_graph graph;
 
auto t1 = graph.create_task([] { return compute_data(); });
auto t2 = graph.create_task([] { return load_config(); });
auto t3 = graph.create_task([](auto data, auto config) {
    return process(data, config);
}, t1, t2);  // t3 зависит от t1 и t2
 
graph.wait_for(t3);  // Дождаться выполнения t3 и всех зависимостей

# Пример современного CMake с использованием менеджера пакетов
cmake_minimum_required(VERSION 3.20)
project(ModernCppExample VERSION 1.0)
 
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
find_package(fmt CONFIG REQUIRED)
find_package(spdlog CONFIG REQUIRED)
find_package(nlohmann_json CONFIG REQUIRED)
 
add_executable(MyApp main.cpp)
target_link_libraries(MyApp PRIVATE 
  fmt::fmt 
  spdlog::spdlog
  nlohmann_json::nlohmann_json
)