Modern Cpp

#include <concepts>

template <std::integral T>
T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); }

template <std::invocable<int> F>
void apply(F&& fn, int value) { fn(value); }

template <typename T>
concept Serializable = requires(T obj, std::ostream& os) {
    { obj.serialize(os) } -> std::same_as<void>;
    { T::deserialize(os) } -> std::same_as<T>;
};

void save(const Serializable auto& obj, std::ostream& os) {
    obj.serialize(os);
}

// One-off: use requires
template <typename T>
    requires (sizeof(T) <= 16)
void small_copy(T value);

// Reusable: define a concept
template <typename T>
concept SmallType = sizeof(T) <= 16;

// BEFORE: SFINAE — cryptic, fragile
template <typename T,
          typename = std::enable_if_t<std::is_arithmetic_v<T>>>
T square(T x) { return x * x; }
// Error: "no matching function for call to 'square'" + 50 lines of template noise

// AFTER: concepts — readable, clear errors
template <typename T>
    requires std::is_arithmetic_v<T>
T square(T x) { return x * x; }
// Error: "constraint 'is_arithmetic_v<string>' not satisfied"

#include <ranges>
#include <algorithm>

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// View pipeline — lazy, no intermediate allocations
auto result = data
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::views::transform([](int x) { return x * x; });

// Range algorithms — accept ranges directly
std::ranges::sort(data);
auto it = std::ranges::find(data, 42);
auto [mn, mx] = std::ranges::minmax(data);

#include <span>

// BEFORE: dangerous — no size information
void process(int* data, size_t len);

// AFTER: carries size, bounds-checkable
void process(std::span<int> data) {
    for (auto& val : data) { /* safe iteration */ }
    data[0];    // unchecked by default; bounds-checked under hardened libc++
                // (_LIBCPP_HARDENING_MODE). span has no .at() until C++26.
}

// Works with any contiguous container
std::vector<int> vec = {1, 2, 3};
std::array<int, 3> arr = {4, 5, 6};
int c_arr[] = {7, 8, 9};

process(vec);    // implicit conversion
process(arr);    // implicit conversion
process(c_arr);  // implicit conversion

#include <format>

std::string s = std::format("Hello, {}!", name);
std::string t = std::format("{:>10.2f}", 3.14159);   // right-aligned, 2 decimal
std::string u = std::format("{:#x}", 255);            // 0xff
std::string v = std::format("{:%Y-%m-%d}", std::chrono::system_clock::now());

template <>
struct std::formatter<Point> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
    auto format(const Point& p, format_context& ctx) const {
        return std::format_to(ctx.out(), "({}, {})", p.x, p.y);
    }
};

// Now works:
std::println("Position: {}", my_point);

#include <compare>

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;
    // Generates: ==, !=, <, >, <=, >=
};

struct Version {
    int major, minor, patch;
    std::strong_ordering operator<=>(const Version& other) const {
        if (auto cmp = major <=> other.major; cmp != 0) return cmp;
        if (auto cmp = minor <=> other.minor; cmp != 0) return cmp;
        return patch <=> other.patch;
    }
    bool operator==(const Version&) const = default;
};

struct Config {
    int port = 8080;
    bool verbose = false;
    int max_connections = 100;
};

// Clear which fields are being set
Config cfg = {.port = 3000, .verbose = true};
// .max_connections gets its default value (100)

#include <thread>

// BEFORE: forgetting to join causes std::terminate
std::thread t(work);
// ... if exception thrown here, t.join() never called → crash

// AFTER: auto-joins on destruction
std::jthread t(work);
// destructor calls request_stop() then join() — always safe

// Cooperative cancellation via stop token
std::jthread worker([](std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        do_work();
    }
});
worker.request_stop();  // signal the thread to exit
// destructor waits for thread to finish

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

for (auto val : range(0, 10)) {
    std::println("{}", val);
}