C++ Control Flow: Structured Bindings, if-init, switch, Ranges & Modern Iteration (C++23)

#include <map>
#include <tuple>
#include <string>
#include <utility>
#include <iostream>

int main() {
    // === 1. Decompose std::pair ===
    std::pair<std::string, int> p = {"temperature", 98};
    auto [metric, value] = p;  // metric="temperature", value=98
    std::cout << metric << ": " << value << '\n';
    
    // === 2. Decompose std::tuple ===
    auto stats = std::make_tuple(42.5, 10, 99.9);
    auto [mean, count, max_val] = stats;
    
    // === 3. Iterate map without .first/.second ===
    std::map<std::string, int> inventory = {
        {"sword", 3}, {"shield", 1}, {"potion", 15}
    };
    
    // OLD style (verbose, error-prone):
    for (auto& item : inventory) {
        std::cout << item.first << ": " << item.second << '\n';
    }
    
    // MODERN style (clear, self-documenting):
    for (const auto& [item_name, quantity] : inventory) {
        std::cout << item_name << ": " << quantity << '\n';
    }
    
    // === 4. Decompose structs ===
    struct Point { double x, y, z; };
    Point origin{0.0, 0.0, 0.0};
    auto [x, y, z] = origin;
    
    // === 5. Bindings to references — can modify original ===
    auto& [sx, sy, sz] = origin;  // References to members
    sx = 1.0;  // Modifies origin.x directly
    
    return 0;
}

#include <tuple>

class RGB {
public:
    uint8_t r, g, b;
    explicit RGB(uint8_t r, uint8_t g, uint8_t b) : r(r), g(g), b(b) {}
    
    template<size_t I>
    auto get() const {
        if constexpr (I == 0) return r;
        if constexpr (I == 1) return g;
        if constexpr (I == 2) return b;
    }
};

// Required specializations in std namespace
namespace std {
    template<> struct tuple_size<RGB> : integral_constant<size_t, 3> {};
    template<size_t I> struct tuple_element<I, RGB> {
        using type = uint8_t;
    };
}

// Now RGB works with structured bindings:
RGB red{255, 0, 0};
auto [r, g, b] = red;  // r=255, g=0, b=0

#include <map>
#include <optional>

std::map<int, std::string> user_db;

// OLD: name leaks into outer scope
auto it = user_db.find(42);
if (it != user_db.end()) {
    process(it->second);
}
// 'it' still exists here — potential misuse!

// MODERN C++17: name confined to if-else block
if (auto it = user_db.find(42); it != user_db.end()) {
    process(it->second);
} else {
    // 'it' is still accessible in else — still in the if scope
    log_not_found(it); // it == user_db.end()
}
// 'it' does NOT exist here — tight scoping

// Works with std::optional too
std::optional<std::string> opt_val = try_parse("42");
if (auto val = try_parse(input); val.has_value()) {
    use(*val);
} // val not accessible here

// Works with mutex locking (lock is released when if block ends):
if (auto lock = std::unique_lock(mutex, std::try_to_lock); lock.owns_lock()) {
    modify_shared_resource();
} // Mutex released here, whether success or failure

enum class ConnectionState { Connecting, Active, Closed, Error };

// OLD — connectionState leaks outside switch
ConnectionState get_state();
auto state = get_state();
switch (state) {
    case ConnectionState::Active: handle_data(); break;
    default: disconnect();
}
// 'state' still alive here — unnecessary

// MODERN — state scoped to switch block
switch (auto state = get_state(); state) {
    case ConnectionState::Connecting:
        start_timeout_timer();
        break;
    case ConnectionState::Active:
        handle_data();
        break;
    case ConnectionState::Closed:
    case ConnectionState::Error:
        disconnect();
        break;
    // GCC -Wswitch warns if enum values are missing!
}

// OLD C-style enum — dangerous
enum Direction { North, South, East, West }; // North leaks into global scope
int n = North; // Implicit int conversion — this should NOT be allowed

// MODERN scoped enum
enum class Direction { North, South, East, West };
// Direction::North is the only access path — no name leaking
// int n = Direction::North; // ERROR: no implicit conversion

Direction d = Direction::East;
// switch with exhaustiveness checking (with -Wswitch):
switch (d) {
    case Direction::North: move(0, 1);  break;
    case Direction::South: move(0, -1); break;
    case Direction::East:  move(1, 0);  break;
    // WARNING: 'West' not handled!
}

// Underlying type (useful for bit flags or serialization):
enum class Permissions : uint8_t {
    None    = 0,
    Read    = 1 << 0,
    Write   = 1 << 1,
    Execute = 1 << 2,
};

// Enable bitwise operations on enum class:
Permissions p = Permissions::Read | Permissions::Write; // via operator overload

#include <vector>
#include <ranges>

std::vector<int> nums = {5, 3, 8, 1, 9, 2};

// Read-only — use const auto&
for (const auto& n : nums) { /* n is const ref — no copy */ }

// Modify in place — use auto&
for (auto& n : nums) { n *= 2; }

// Copy each element — use auto (rare, usually a mistake for large objects)
for (auto n : nums) { /* n is copy */ }

// Reverse iteration (C++20 std::views::reverse)
#include <ranges>
for (const auto& n : nums | std::views::reverse) {
    std::cout << n << ' ';
}

// Enumerate with index (C++23 std::views::enumerate)
for (auto [i, n] : nums | std::views::enumerate) {
    std::cout << i << ": " << n << '\n';  // index + value
}

// Filter and transform pipeline (C++20 ranges)
auto even_squares = nums
    | std::views::filter([](int n){ return n % 2 == 0; })
    | std::views::transform([](int n){ return n * n; });

for (int x : even_squares) { std::cout << x << ' '; }
// Lazy — no intermediate vector created!

#include <compare>

struct Version {
    int major, minor, patch;
    
    // C++20: One declaration generates all six comparison operators
    auto operator<=>(const Version&) const = default;
    // Also generates: ==, !=, <, >, <=, >=
};

Version v1{1, 2, 3}, v2{1, 3, 0};
if (`v1 < v2`) std::cout << "v1 is older\n";  // Works via `<=>`
if (v1 == v2) std::cout << "same version\n";

// Spaceship returns a comparison category:
// std::strong_ordering  — total order (int, float, custom)
// std::weak_ordering    — some elements may be equivalent
// std::partial_ordering — some elements incomparable (NaN)
auto result = `v1 <=> v2`;      //  std::strong_ordering::less
bool is_less = (result < 0);  // true

#include <variant>
#include <string>
#include <iostream>

using Token = std::variant<int, double, std::string, bool>;

// Visitor with overloaded lambdas (C++17 pattern)
struct Printer {
    void operator()(int n)               { std::cout << "Int: " << n << '\n'; }
    void operator()(double d)            { std::cout << "Double: " << d << '\n'; }
    void operator()(const std::string& s){ std::cout << "String: " << s << '\n'; }
    void operator()(bool b)              { std::cout << "Bool: " << b << '\n'; }
};

// Overloaded helper (C++17)
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

int main() {
    Token t1 = 42;
    Token t2 = 3.14;
    Token t3 = std::string{"hello"};
    
    // Dispatch to the correct handler based on runtime type
    std::visit(Printer{}, t1);  // "Int: 42"
    std::visit(Printer{}, t2);  // "Double: 3.14"
    
    // With overloaded lambdas:
    auto visitor = overloaded{
        [](int n)    { return n * 2; },
        [](double d) { return (int)(d * 2); },
        [](auto&&)   { return 0; },  // Catch-all
    };
    
    std::cout << std::visit(visitor, t1) << '\n'; // 84
}

#include <ranges>
#include <vector>
#include <string>

std::vector<std::string> names = {"Alice", "Bob", "Carol"};
std::vector<int> scores = {95, 82, 78};

// zip: iterate two ranges in pairs (C++23)
for (auto [name, score] : std::views::zip(names, scores)) {
    std::cout << name << ": " << score << '\n';
}

// enumerate: index + value (C++23)
for (auto [i, name] : std::views::enumerate(names)) {
    std::cout << i << ". " << name << '\n';
}
// 0. Alice
// 1. Bob
// 2. Carol