C++17 & C++20

// Unpack tuples, pairs, structs
auto [x, y] = std::make_pair(3, 4.5f);

struct Point { int x, y, z; };
Point p{1, 2, 3};
auto [px, py, pz] = p;

// In range-based for over maps
std::map<std::string, int> registers = {
    {"CTRL",   0x40},
    {"STATUS", 0x41}
};
for (auto& [name, addr] : registers)
    std::cout << name << " = 0x" << std::hex << addr << '\n';

// C++17: initialiser inside if statement
if (auto it = map.find("key"); it != map.end()) {
    // it is scoped to this block
    use(it->second);
}

// switch with init
switch (auto status = get_device_status(); status) {
    case DeviceStatus::Ready:  handle_ready(); break;
    case DeviceStatus::Error:  handle_error(); break;
    default: break;
}

template <typename T>
auto process(T val) {
    if constexpr (std::is_integral_v<T>) {
        return val * 2;             // compiled for integer types
    } else if constexpr (std::is_floating_point_v<T>) {
        return val * 2.0f;          // compiled for float types
    } else {
        static_assert(always_false<T>, "Unsupported type");
    }
}

// C++17: no need to specify template arguments
std::pair p(3, 4.5f);           // pair<int, float>
std::vector v = {1, 2, 3, 4};  // vector<int>
std::array arr{1.0, 2.0, 3.0}; // array<double, 3>

#include <optional>

// Return a value OR nothing — no null pointers!
std::optional<float> read_sensor(int id) {
    if (id < 0 || id >= MAX_SENSORS) return std::nullopt;
    return sensor_values[id];
}

auto val = read_sensor(5);
if (val.has_value())
    std::cout << *val << '\n';          // dereference

// With value_or
float v = read_sensor(id).value_or(0.0f);  // default if empty

#include <variant>

// Type-safe union — holds exactly ONE of the listed types
using Result = std::variant<float, std::string>;  // value or error message

Result read_temperature() {
    float temp = hw_read();
    if (temp < -273.0f) return std::string("sensor fault");
    return temp;
}

auto r = read_temperature();

// std::visit — pattern matching
std::visit([](auto&& v) {
    using T = std::decay_t<decltype(v)>;
    if constexpr (std::is_same_v<T, float>)
        std::cout << "temp: " << v << '\n';
    else
        std::cerr << "error: " << v << '\n';
}, r);

// Or check type directly
if (std::holds_alternative<float>(r))
    std::cout << std::get<float>(r) << '\n';

#include <string_view>

// Non-owning view of a string — no allocation, no copy
void print_name(std::string_view name) {    // accepts string, const char*, string_view
    std::cout << name.substr(0, 4) << '\n'; // O(1) substr
}

print_name("hello world");         // no allocation
std::string s = "hello world";
print_name(s);                     // no copy

// WARNING: string_view does NOT own the data — don't store it past the original's lifetime

#include <filesystem>
namespace fs = std::filesystem;

// List directory
for (const auto& entry : fs::directory_iterator("/etc")) {
    if (entry.is_regular_file())
        std::cout << entry.path().filename() << " "
                  << entry.file_size() << " bytes\n";
}

// Path operations
fs::path p = "/usr/local/bin/myapp";
std::cout << p.filename()   << '\n';  // "myapp"
std::cout << p.parent_path()<< '\n';  // "/usr/local/bin"
std::cout << p.extension()  << '\n';  // ""

// File operations
fs::create_directories("/tmp/myapp/logs");
fs::copy_file("src.txt", "dst.txt");
fs::remove("/tmp/old.txt");
bool exists = fs::exists("/etc/hostname");

#include <concepts>

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

// Constrained function template
template <Numeric T>
T clamp(T val, T lo, T hi) {
    return (val < lo) ? lo : (val > hi) ? hi : val;
}

// Shorter syntax (abbreviated function template)
auto clamp2(Numeric auto val, Numeric auto lo, Numeric auto hi) {
    return (val < lo) ? lo : (val > hi) ? hi : val;
}

// Standard library concepts (in <concepts>)
// std::integral, std::floating_point, std::same_as<T,U>,
// std::derived_from<T,Base>, std::convertible_to<T,U>,
// std::regular, std::invocable<F, Args...>

#include <ranges>

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

// Composable range adaptors with | pipe
auto squares_of_evens = v
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::views::transform([](int x) { return x * x; });

for (int n : squares_of_evens)
    std::cout << n << ' ';   // 4 16 36 64 100

// std::ranges algorithms — no begin/end!
std::ranges::sort(v);
std::ranges::reverse(v);
auto it = std::ranges::find(v, 5);

// iota view
for (int i : std::views::iota(1, 6))
    std::cout << i << ' ';   // 1 2 3 4 5

#include <format>

std::string s = std::format("Sensor {:02d}: {:.2f} °C", 5, 23.456f);
// "Sensor 05: 23.46 °C"

std::cout << std::format("0x{:08X}\n", 0xDEAD);  // "0x0000DEAD"

// Logging with format
auto log = [](std::string_view level, std::string_view msg) {
    std::cout << std::format("[{}] {}\n", level, msg);
};
log("INFO", "device initialised");

#include <compare>

struct Version {
    int major, minor, patch;

    auto operator<=>(const Version&) const = default;  // generates all 6 comparisons
};

Version v1{1, 2, 3}, v2{1, 3, 0};
bool ok = v1 < v2;    // true
bool eq = v1 == v2;   // false
// Also generates >, >=, <=, !=

#include <coroutine>
#include <generator>   // C++23; use a library for C++20

// Simple generator using co_yield
std::generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;          // suspend, return value to caller
        auto next = a + b;
        a = b;
        b = next;
    }
}

// Use the generator
for (int n : fibonacci() | std::views::take(10))
    std::cout << n << ' ';   // 0 1 1 2 3 5 8 13 21 34

// co_await — suspend until async operation completes
// co_return — return from coroutine