cpp17 · high

C++17 Features — With Use Cases

C++17's practical features with use cases. Structured bindings unpack pairs/tuples/structs; if/switch with initializer scopes a variable to the branch (ideal for find/insert). optional models fallible results, variant is a type-safe union with std::visit, any is type-erased. if constexpr branches at compile time (untaken branch not instantiated) and fold expressions collapse parameter packs — together replacing SFINAE and recursive variadics. string_view is a non-owning, zero-copy string parameter (beware dangling). CTAD drops explicit <T>; inline variables give header-only single definitions; [[nodiscard]] warns on ignored results; parallel algorithms take an execution policy. Copy elision is guaranteed for prvalues, making by-value factory returns free.

The code

// C++17 — the features you actually use
auto [it, ok] = m.insert({k, v});           // structured bindings
if (auto it = m.find(k); it != m.end()) {}  // if-with-init
std::optional<int> parse(std::string_view); // optional + string_view
std::variant<int, std::string> v;           // type-safe union
template <class T>
auto f(T x) {
    if constexpr (std::is_integral_v<T>) // compile-time branch
        return x * 2;
    else
        return x + "!";
}
template <class... A>
auto sum(A... a) {
    return (a + ...);
} // fold
std::vector v{1, 2, 3};               // CTAD (no <int>)
std::sort(std::execution::par, b, e); // parallel algorithms

What this lesson walks through

1. 01Structured bindings + if/switch with initializer
2. 02std::optional / variant / any — vocabulary types
3. 03if constexpr + fold expressions — compile-time templates
4. 04std::string_view + std::filesystem
5. 05CTAD, inline variables, [[nodiscard]], parallel algorithms
6. 06Guaranteed copy elision + the C++17 cheat sheet

Structured bindings unpack a pair/tuple/struct/array into named variables: auto [it, inserted] = m.insert(...). The if-with-initializer scopes a variable to the if/else: if (auto it = m.find(k); it != m.end()) — it is visible in both branches but dies at the end, keeping the enclosing scope clean and avoiding accidental reuse. Together they make map/insert/find code dramatically cleaner.