一篇文章掌握 C++14 通用 Lambda：让你的代码既简洁又高效

// 只能处理 int 的 Lambda 🚫
auto multiply = [](int x, int y) { 
    return x * y;  // 类型硬编码，不够灵活！
};

// 处理 int 的版本 → ✅
auto multiply_int = [](int x, int y) { return x * y; };

// 处理 double → 又写一遍 😩
auto multiply_double = [](double x, double y) { return x * y; };

// 处理 long → 重复劳动 🤯
auto multiply_long = [](long x, long y) { return x * y; };

// 一个 Lambda 通吃所有类型 🎯
auto magic_multiply = [](auto x, auto y) { 
    return x * y;  // 编译器自动推导类型 💎
};

magic_multiply(2, 3);    // → 6 (int) ✅
magic_multiply(1.5, 4);  // → 6.0 (double) ✅
magic_multiply(2L, 5L);  // → 10 (long) ✅

// 整型计算 🌟
auto result_int = magic_multiply(42, 10);  // 编译器自动识别为 int
std::cout << "42 × 10 = " << result_int << "\n";  // 📤 输出 420

// 浮点运算 🎯
auto result_double = magic_multiply(3.14, 2.0);  // 自动推导为 double
std::cout << "π × 2 = " << result_double << "\n";  // 📤 输出 6.28

// 跨类型运算 💫
auto mix_result = magic_multiply(2, 3.14);  // int × double → double
std::cout << "混合运算结果：" << mix_result << "\n";  // 📤 输出 6.28

auto print_container = [](const auto& container) { // 👉 自动识别任何容器！
    std::cout << "📦 容器内容 → ";  // 🖨️ 统一前缀
    for (const auto& item : container) {  // 🔄 智能遍历
        std::cout << item << " ";  // ✨ 元素逐个打印
    }
    std::cout << std::endl;  // 🎯 完美收尾
};

// 整型容器测试 🔢
std::vector<int> nums{1,2,3};  // 📦 创建vector
print_container(nums);  // 🖨️ 输出：1 2 3

// 字符串容器测试 📚
std::list<std::string> words{"嗨","你好","早安"};  // 📜 链表容器
print_container(words);  // 🖨️ 输出：嗨 你好 早安

auto find_element = [](const auto& container,  // 🗃️ 装任何容器！
                      const auto& value) {     // 🔍 找任何东西！
    return std::find(std::begin(container),    // 🏁 起点
                    std::end(container),      // 🏁 终点
                    value) != std::end(container); // 🎯 找到就亮灯！
};

// 找数字就像找彩蛋 🥚
std::vector<int> nums = {1,2,3,4,5};
std::cout << find_element(nums, 3);  // ✅ 输出 1 (true) 🎉
std::cout << find_element(nums, 42); // ❌ 输出 0 (false) 😅

// 找水果就像在果园采摘 🍎
std::vector<std::string> fruits = {"🍎","🍌","🍊"};
// 👇 注意苹果藏在第一个位置！
std::cout << find_element(fruits, "🍎"); // ✅ 输出 1 🌟

// 甚至找结构体也不在话下！ 🛠️
struct Point { int x,y; };
std::vector<Point> points{{1,2}, {3,4}};
std::cout << find_element(points, Point{3,4}); // ✅ 找到！🚀

// 🚨 警告！代码膨胀警告！
struct Multiplier {
    template<typename T, typename U>  // 📝 要声明两个类型
    auto operator()(T x, U y) const  // 📦 必须包裹在结构体里
        -> decltype(x * y) {         // 🤯 还要推导返回类型
        return x * y;
    }
};

auto multiplier = [](auto x, auto y) { 
    return x * y;  // 🌈 自动推导所有类型！
};
// 💡 1行 vs 旧版7行！代码减肥成功 🏋️♂️

std::vector<std::variant<int, std::string>> items = {
    42,       // 🧊 数字
    "hello",  // 🎪 字符串
    123       // 🔢 又是数字
};

// 外层Lambda：快递员 📦
std::for_each(items.begin(), items.end(), 
    [](const auto& item) {  // 🔍 自动识别任何类型
    
    // 内层Lambda：拆包专家 🕵️♂️
    std::visit([](const auto& v) {
        std::cout << v << "\n";  // 🖨️ 通吃int/string
    }, item);
});
// 💡 就像俄罗斯套娃，但每个都会变魔术 🎩

auto make_factory = [](auto&& ... args) {  // 🎒 百变参数包
    return std::make_unique<MyClass>(
        std::forward<decltype(args)>(args)...  // 🚚 原样运输
    );
};

// 送快递啦！📦→📦
auto p1 = make_factory(42);             // 🎯 精准送达int
auto p2 = make_factory("cpp", 3.14);    // 🚀 混合类型大礼包
// 💡 保持参数新鲜度，就像冷链运输 🚚❄️

auto universal_adder = [](auto x, auto y) { 
    return x + y;  // 🎩 万能加法公式
};

class __HiddenAdder__ {  // 🧰 编译器生成的秘密类
public:
    // 🔮 每个auto参数都会变成模板参数
    template<typename T, typename U>
    ...
};

auto operator()(T x, U y) const { 
        return x + y;  // 🦾 原样复制Lambda函数体
    }

// 当我们调用时：
universal_adder(3, 3.14);  // 🧙♂️ 自动推导T=int, U=double

// 等价于：
__HiddenAdder__().operator()<int, double>(3, 3.14);

// 🦄 定义万能加法器
auto add = [](auto x, auto y) { 
    return x + y;  // 🔄 自动适配所有可加类型
};

int result = add(1, 2);  // 🎯 具体调用

int __lambda_adder(int x, int y) {
    return x + y;  // ⚡️ 直接硬编码！
}

int result = 1 + 2;  // 🎩 魔法变身！

int result = 3;  // 💫 终极优化形态！

auto safe_processor = [](const auto& val) {
    // 🔍 编译期类型检查：只允许数值类型
    static_assert(std::is_arithmetic<std::decay_t<decltype(val)>>::value,
                 "Only numbers allowed! 🚫");
    return val * 2; 
};

auto type_spy = [](auto&& param) {
    using RawType = std::decay_t<decltype(param)>; // 🧼 去除引用和cv限定
    std::cout << "发现类型 → " << typeid(RawType).name() 
              << " 👉 sizeof: " << sizeof(RawType) << " bytes\n";
    return std::forward<decltype(param)>(param); // 🚀 完美转发保持值类别
};

type_spy(42);    // 🔢 输出 int 类型信息
type_spy(3.14);  // 🎯 输出 double 类型信息
type_spy("C++"); // 🧩 输出 const char* 信息

// 🌟 万能比较器：自动适配所有可比较类型
auto find_max = [](auto a, auto b) { 
    return a > b ? a : b;  // 🚦 核心逻辑：比大小
};

int max_int = find_max(10, 20);    // ✅ 整型比较 → 20
double max_double = find_max(3.14, 2.71);  // 🎯 浮点比较 → 3.14

// 🧩 字符串比较（按字典序）
std::string max_str = find_max("apple", "zebra");  // 🍎 vs 🦓 → "zebra"

// ⚡️ 混合类型比较（自动类型提升）
auto max_mixed = find_max(10, 20.5);  // 🔄 int → double → 20.5