// 1. 处理std::pair/map，彻底告别first/second
std::map<int, std::string> mp{{1, "hello"}, {2, "world"}};
for (const auto& [key, value] : mp) {
    std::cout << key << ":" << value << "\n";
}

// 2. 处理数组
int arr[3] = {1, 2, 3};
auto [x, y, z] = arr; // x=1, y=2, z=3

// 3. 处理结构体
struct Point { int x; double y; };
Point p{10, 3.14};
auto [px, py] = p;

// 4. 支持引用/const修饰
const auto& [rx, ry] = p;

// 头文件 header.h
#pragma once

// 全局内联变量，头文件直接定义，多cpp包含无链接冲突
inline constexpr double PI = 3.141592653589793;
inline int global_config = 100;

// 类的静态内联成员，无需在cpp中额外定义
struct Test {
    inline static int static_var = 200;
    // constexpr静态成员默认隐式inline，无需额外加inline
    constexpr static int constexpr_var = 300;
};

// 1. 可变参数求和
template <typename... Args>
auto sum(Args... args) {
    return (... + args); // 一元左折叠
}
sum(1, 2, 3, 4); // 结果10

// 2. 可变参数打印
template <typename... Args>
void print_all(Args&&... args) {
    (std::cout << ... << args) << "\n"; // 二元左折叠
}
print_all(1, " hello ", 3.14); // 输出1 hello 3.14

// 3. 所有参数都为true
template <typename... Args>
bool all_true(Args... args) {
    return (... && args);
}

// 1. 标准库容器/工具类
std::pair p(1, 3.14); // 自动推导为std::pair<int, double>
std::tuple t(1, "hello", 2.5); // 推导为std::tuple<int, const char*, double>
std::vector vec{1, 2, 3, 4}; // 推导为std::vector<int>
std::lock_guard lock(mtx); // 推导为std::lock_guard<std::mutex>，RAII代码更简洁
std::array arr{1, 2, 3}; // 推导为std::array<int, 3>

// 2. 自定义类模板
template <typename T>
struct Test {
    Test(T a, T b) : x(a), y(b) {}
    T x, y;
};
Test t(10, 20); // 自动推导T=int，无需Test<int> t(10,20)

// 编译期可执行的Lambda
constexpr auto add = [](sslocal://flow/file_open?url=int+a%2C+int+b&flow_extra=eyJsaW5rX3R5cGUiOiJjb2RlX2ludGVycHJldGVyIn0=) constexpr { return a + b; };
constexpr int res = add(10, 20); // 编译期计算，res=30

// 编译期生成数组
template <int N>
constexpr auto make_arr() {
    std::array<int, N> arr{};
    auto fill = [&arr](sslocal://flow/file_open?url=int+i&flow_extra=eyJsaW5rX3R5cGUiOiJjb2RlX2ludGVycHJldGVyIn0=) constexpr { arr[i] = i; };
    for (int i = 0; i < N; ++i) fill(i);
    return arr;
}
constexpr auto arr = make_arr<5>(); // 编译期完成数组初始化

struct Test {
    int x = 100;
    auto get_safe_lambda() {
        // 捕获*this的副本，Lambda持有当前对象的完整拷贝，与原对象生命周期独立
        return  { return x; };
    }
    auto get_unsafe_lambda() {
        return  { return x; }; // 仅捕获this指针，易出现悬空
    }
};

// 安全场景：临时对象销毁后，Lambda仍可正常调用
auto safe_lambda = Test{}.get_safe_lambda();
safe_lambda(); // 合法，返回100，无悬空指针

// 危险场景：临时对象销毁后，this指针悬空，调用为未定义行为
auto unsafe_lambda = Test{}.get_unsafe_lambda();

struct NonCopyable {
    NonCopyable() = default;
    // 拷贝和移动构造函数都被删除
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable(NonCopyable&&) = delete;
};

// C++17之前：编译报错，需要可访问的移动构造（即使RVO优化）
// C++17及之后：编译通过，直接在目标对象上构造，无任何拷贝/移动
NonCopyable obj = NonCopyable();

// 函数返回场景
NonCopyable create() {
    return NonCopyable(); // 直接在调用方的对象上构造，无拷贝/移动
}
NonCopyable obj2 = create(); // 完全合法

#include <optional>

// 函数返回可选值：成功返回计算结果，失败返回无值
std::optional<int> divide(int a, int b) {
    if (b == 0) return std::nullopt; // 无值状态
    return a / b; // 有值状态
}

// 使用方式
auto res = divide(10, 2);
if (res.has_value()) { // 判断是否有值
    std::cout << res.value() << "\n"; // 取值，无值则抛异常
}
std::cout << res.value_or(0) << "\n"; // 有值返回值，无值返回默认值0
if (res) { // 简写判断
    std::cout << *res << "\n"; // 指针式解引用
}

#include <variant>

// 定义可存储int、double、std::string的variant
std::variant<int, double, std::string> var;

var = 10; // 存储int，index()=0
var = 3.14; // 存储double，index()=1
var = "hello world"; // 存储std::string，index()=2

// 类型判断与取值
if (std::holds_alternative<int>(var)) {
    std::cout << "int: " << std::get<int>(var) << "\n";
}
// 取值失败会抛std::bad_variant_access异常
auto* ptr = std::get_if<std::string>(&var); // 安全取值，失败返回nullptr

// visit访问者模式，统一处理所有类型
std::visit([](sslocal://flow/file_open?url=auto%26%26+arg&flow_extra=eyJsaW5rX3R5cGUiOiJjb2RlX2ludGVycHJldGVyIn0=) {
    std::cout << arg << "\n";
}, var);

#include <any>

std::any a;
a = 10; // 存储int
a = std::string("hello"); // 存储std::string
a = 3.14; // 存储double

// 访问与判断
if (a.has_value() && a.type() == typeid(double)) {
    std::cout << std::any_cast<double>(a) << "\n";
}
// 类型转换失败会抛std::bad_any_cast异常

#include <string_view>

// 函数参数，替代const std::string&，无任何内存拷贝
void print(std::string_view sv) {
    std::cout << sv << "\n";
}

print("hello world"); // 直接传字符串字面量，无拷贝
std::string s = "test string";
print(s); // 直接传std::string，无拷贝

// 子串操作，O(1)复杂度，无内存分配
std::string_view sv = "abcdefg";
auto sub = sv.substr(1, 3); // sub为"bcd"，仅调整指针和长度

// std::void_t检测类是否有x成员
template <typename T, typename = void>
struct has_x : std::false_type {};
template <typename T>
struct has_x<T, std::void_t<decltype(std::declval<T>().x)>> : std::true_type {};

// std::conjunction检测所有类型都是整数
template <typename... Args>
constexpr bool all_integral = std::conjunction_v<std::is_integral<Args>...>;

std::map<int, std::string> mp;
// 仅当key=1不存在时，才构造std::string
mp.try_emplace(1, "hello");
// key=1存在则赋值，不存在则插入
mp.insert_or_assign(1, "world");

// 节点拼接，无元素拷贝
std::map<int, std::string> mp2{{2, "test"}, {3, "cpp"}};
mp.merge(mp2); // mp2的节点全部转移到mp，mp2变为空

int arr[5] = {1,2,3,4,5};
std::size(arr); // 返回5
std::data(arr); // 返回数组首地址
std::empty(arr); // 返回false

int x = 10;
x = std::clamp(x, 0, 5); // x被限制为5

std::gcd(12, 18); // 返回6
std::lcm(12, 18); // 返回36

void func(int a, double b, const std::string& c) {}
std::tuple t(1, 3.14, "hello");
std::apply(func, t); // 等价于func(1, 3.14, "hello")

struct Test { Test(int a, double b) {} };
auto obj = std::make_from_tuple<Test>(std::make_tuple(10, 3.14));