C++ variant / optional / any

// compile: g++ -std=c++17 optional_demo.cpp && ./a.out
#include <iostream>
#include <optional>
#include <string>
#include <unordered_map>

std::optional<int> find_age(const std::unordered_map<std::string, int>& m,
                            const std::string& name) {
    if (auto it = m.find(name); it != m.end()) {
        return it->second;          // 有值
    }
    return std::nullopt;            // 无值（可省略，返回 {} 同义）
}

int main() {
    std::unordered_map<std::string, int> ages{{"Alice", 30}};

    if (auto age = find_age(ages, "Alice")) {      // 直接当 bool 用
        std::cout << "Alice: " << *age << '\n';    // 30
    }

    auto bob = find_age(ages, "Bob");
    std::cout << bob.value_or(-1) << '\n';         // -1：无值时给默认值

    // bob.value();  // 无值时抛 std::bad_optional_access
    // *bob;         // 无值时是未定义行为！比 value() 更危险
}

// C++23：值存在则应用函数返回新 optional，否则整条链短路为空
auto name = find_age(ages, "Alice")
    .and_then([](int i) { return std::optional{std::to_string(i)}; })
    .transform([](const std::string& s) { return "age=" + s; });
// name 此刻持有 "age=30"

// compile: g++ -std=c++17 variant_demo.cpp && ./a.out
#include <iostream>
#include <string>
#include <variant>

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

void print(const Value& v) {
    // 首选：std::visit + 重载访问者，编译器强制覆盖所有分支
    std::visit([](auto&& x) { std::cout << x << '\n'; }, v);
}

int main() {
    Value v = 42;                       // 当前持有 int
    std::cout << v.index() << '\n';     // 0：int 的位置索引

    v = std::string("hi");              // 切换到 string（旧值被正确销毁）

    // 检查当前类型
    if (std::holds_alternative<std::string>(v)) {
        std::cout << "持有 string\n";
    }

    // 取值：get 抛异常，get_if 返回指针不抛
    std::string& s = std::get<std::string>(v);      // 类型不符抛 bad_variant_access
    if (auto* p = std::get_if<std::string>(&v)) {   // 推荐：先试探
        std::cout << *p << '\n';                    // hi
    }

    print(v);
}

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

std::visit(overloaded{
    [](int i)        { std::cout << "int: " << i << '\n'; },
    [](double d)     { std::cout << "double: " << d << '\n'; },
    [](const std::string& s) { std::cout << "str: " << s << '\n'; }
}, v);

// compile: g++ -std=c++17 any_demo.cpp && ./a.out
#include <any>
#include <iostream>
#include <string>

int main() {
    std::any a;                          // 空的
    std::cout << a.has_value() << '\n';  // 0

    a = 42;
    a = std::string("hi");               // 后赋值覆盖前值（旧值销毁）
    a.reset();                           // 清空；也可以 a = {}（不要写 = std::nullopt，那是 optional 的）

    a = 3.14;
    if (a.type() == typeid(double)) {    // 运行期类型查询
        std::cout << std::any_cast<double>(a) << '\n';   // 3.14
    }

    if (auto* p = std::any_cast<double>(&a)) {           // 指针形式：不匹配得 nullptr
        std::cout << *p << '\n';
    }
}

std::optional<T>          std::variant<A, B>         std::any
+-----------------+       +-----------------+        +-----------------+
| T storage       |       | union { A a;    |        | SBO 内联存储     |
| bool has_value  |       |         B b; }  |        |   或堆指针       |
+-----------------+       | index 判别式     |        | type_info 指针   |
                          +-----------------+        +-----------------+

enum class ShapeKind { Circle, Rect };
struct Shape { ShapeKind kind; double r; double w; double h; };
double area(const Shape& s);   // 内部 switch 判断 kind

#include <cmath>
#include <variant>

struct Circle { double r; };
struct Rect   { double w, h; };
struct Tri    { double a, b, c; };

using Shape = std::variant<Circle, Rect, Tri>;

double area(const Shape& s) {
    return std::visit([](auto&& sh) -> double {
        using T = std::decay_t<decltype(sh)>;
        if constexpr (std::is_same_v<T, Circle>) {
            return 3.14159265358979 * sh.r * sh.r;
        } else if constexpr (std::is_same_v<T, Rect>) {
            return sh.w * sh.h;
        } else {                       // Tri：海伦公式
            double p = (sh.a + sh.b + sh.c) / 2;
            return std::sqrt(p * (p - sh.a) * (p - sh.b) * (p - sh.c));
        }
    }, s);
}
// 给 Shape 增加新候选后：所有「非泛型」的 visit 访问者都会编译报错，
// 逐一补分支即可——维护漏改被编译器接管。

#include <functional>
#include <optional>
#include <unordered_map>

template <class K, class V>
class Cache {
    std::unordered_map<K, V> data_;
public:
    std::optional<V> get(const K& key) const {
        auto it = data_.find(key);
        return it == data_.end() ? std::nullopt : std::optional<V>{it->second};
    }
    const V& get_or_compute(const K& key, std::function<V(const K&)> f) {
        if (auto hit = get(key)) {
            // 注意：不能返回 optional 内部成员的引用（悬垂），
            // 命中路径需要在 map 里再查一次拿到稳定引用
            return data_.find(key)->second;
        }
        return data_.emplace(key, f(key)).first->second;
    }
};