三分钟精通 C++20 Lambda 模版参数

// 定义一个简单的乘法 Lambda 🔢
auto multiply = [](float x, float y) { 
    // 计算两个浮点数的乘积 ✖️
    return x * y;    
}; 

// 调用 Lambda 进行计算 🧮
float result = multiply(
    2.5f,  // 第一个操作数
    3.0f   // 第二个操作数
);  // 结果是 7.5

// 这个 Lambda 比较固执 ⚠️
// 只能处理 float 类型的数据
// 就像个不懂变通的小朋友 👶

// 创建一个通用的连接器 Lambda 🔗
auto concat = [](auto a, auto b) { 
    // 使用 + 运算符连接两个参数 ✨
    return a + b;    
}; 

// 字符串连接示例 📝
auto str = concat(
    "Hello",  // 第一个字符串
    "World"   // 第二个字符串
);  // 结果: HelloWorld

// 数字相加示例 🔢
auto sum = concat(
    10,  // 第一个数字
    20   // 第二个数字
);  // 结果: 30

// 创建一个类型安全的比较器 Lambda 🔍
auto compare = [](
    auto x,         // 第一个参数
    decltype(x) y   // 第二个参数,必须和x同类型
) {
    // 检查两个值是否相等 ✨
    return x == y;   
}; 

// 测试相同类型的比较 ✅
bool ok = compare(
    10,    // 第一个整数
    10     // 第二个整数
);  // 结果为 true

// 下面的代码会编译失败 ❌
// bool nope = compare(
//     10,     // 整数类型
//     10.5    // 浮点类型,类型不匹配!
// ); 

auto max = []<typename T>(T a, T b) {
    return a > b ? a : b;  // 模板让它更专业了
}; 
int result = max(42, 24);  // 这个可以! ✨
// int err = max(42, 24.5);  // 不同类型?不行! ❌

// 使用 auto 的旧方式 🤔
auto oldWay = [](auto x, auto y) {
    // 参数类型可能不一致,存在潜在风险 ⚠️
    return x + y;    
};

// 使用模板参数的新方式 ✨
auto newWay = []<typename T>
    (T x, T y) {
    // 编译期类型检查,保证类型安全 🛡️
    static_assert(
        std::is_arithmetic_v<T>, 
        "Must be numeric type!"
    );
    
    // 保证参数类型一致 ✅
    return x + y;    
};

// 创建一个通用的打印容器函数 🖨️
auto printContainer = [](const auto& c) { 
    // 遍历容器中的每个元素 🔄
    for(const auto& elem : c) {
        // 打印当前元素,添加空格分隔 ✨
        std::cout << elem << " "; 
    }
    // 最后打印换行 ⏎
    std::cout << "\n";
}; 

std::vector<int> nums = {1, 2, 3};
std::list<std::string> strs = {"hello", "world"};
printContainer(nums);    // 1 2 3
printContainer(strs);    // hello world

// 定义一个查找最大值的模板 Lambda 🔍
auto findMax = []<typename T>
    (conststd::vector<T>& vec) {
    // 检查容器是否为空 ⚠️
    if (vec.empty()) {
        throwstd::runtime_error(
            "Vector is empty!"
        );
    }
    
    // 使用 STL 算法查找最大元素 🎯
    return *std::max_element(
        vec.begin(), 
        vec.end()
    );
}; 

// 创建一个测试用的整数向量 📋
std::vector<int> numbers = {
    4, 2, 7, 1, 9
};

// 调用 Lambda 查找最大值 ✨
int max = findMax(numbers);  // 返回 9

// 创建一个只接受浮点数的求和函数 🧮
auto sumNumbers = []<std::floating_point T>
    (conststd::vector<T>& vec) {
    // 使用 accumulate 计算总和
    // 初始值设为 T{} (即 0.0) ✨
    returnstd::accumulate(
        vec.begin(),  // 从开始位置
        vec.end(),    // 到结束位置
        T{}           // 初始值为 0
    );
}; 

// 创建一个测试用的浮点数向量 📊
std::vector<double> doubles = {
    1.2,  // 第一个数
    3.4,  // 第二个数
    5.6   // 第三个数
};

// 调用 Lambda 计算总和 ✨
double sum = sumNumbers(doubles);  
// 结果是 10.2 = 1.2 + 3.4 + 5.6 🎯

// 创建一个完美转发的 Lambda 🎩
auto magicForward = []<typename T>
    // 使用万能引用接收参数 🔄
    (T&& arg) {
    // 完美转发参数,保持值类别不变 ✨
    returnstd::forward<T>(arg);
};

// 使用示例 📝
std::string str = "hello";

// 转发左值 👈
auto& lref = magicForward(str);

// 转发右值 👉
auto rval = magicForward(
    std::string("world")
);

// 创建一个挑剔的排序器 Lambda 🎯
auto pickySorter = []<typename T>
    // 容器参数,使用引用避免拷贝 📦
    (T& container) 
    // 要求容器支持随机访问 ⚡
    requiresstd::ranges::random_access_range<T> 
{
    // 使用 ranges 库进行排序 🔄
    std::ranges::sort(
        container  // 对整个容器排序
    );  
}; 

// 使用示例 ✨
std::vector<int> vec = {3, 1, 4, 1, 5};
pickySorter(vec);  // 可以排序 vector ✅

std::list<int> lst = {3, 1, 4, 1, 5};
// pickySorter(lst);  
// ❌ 编译错误:list 不支持随机访问!

// 创建一个计算阶乘的天才 Lambda 🧮
auto mathGenius = []<typename T>(T n) -> T {
    // 检查是否为整数类型 🔍
    ifconstexpr (std::is_integral_v<T>) {
        // 递归计算阶乘 ➿
        // 基本情况:当 n <= 1 时返回 1
        if (n <= 1) {
            return1;
        }
        
        // 递归情况:n * (n-1)! 
        return n * mathGenius(n - 1);
    } else {
        // 如果不是整数类型就报错 ⚠️
        static_assert(
            std::is_integral_v<T>,
            "只能计算整数的阶乘哦～ 🤓"
        );
    }
};

// 使用示例 ✨
int result = mathGenius(5);  // 计算 5!
// 结果是 120 = 5 * 4 * 3 * 2 * 1

// 以下代码会编译失败 ❌
// double wrong = mathGenius(5.5); 
// 错误:浮点数不能计算阶乘!

// ❌ 糟糕的写法:每次循环都创建新的 Lambda
for (int i = 0; i < n; ++i) {
    // 每次循环都要创建新对象,太浪费了! 😫
    auto lambda = []<typename T>
        (T x) { 
            return x * x; 
        };
    
    // 调用 lambda 计算平方
    result += lambda(i);  
}

// ✨ 推荐写法:在循环外定义 Lambda
// 只创建一次 Lambda 对象 🎯
auto lambda = []<typename T>
    (T x) {
        // 计算并返回平方值
        return x * x;
    };

// 循环中重复使用同一个 Lambda
for (int i = 0; i < n; ++i) {
    // 直接使用已创建的 lambda
    result += lambda(i);  // 性能更好! 🚀
}

// 创建一个类型侦探 Lambda 🔍
auto sherlock = []<typename T>
    (T value) {
    // 在编译期进行类型检查 🎯
    static_assert(
        sizeof(T) > 0, 
        "类型检查: "
        __PRETTY_FUNCTION__
    ); 
    
    // 打印运行时的类型信息 📝
    std::cout
        << "发现类型: "
        << typeid(T).name() 
        << '\n'; 
    
    // 返回原始值 ✨
    return value;
};

// 使用示例 
int num = 42;
sherlock(num);      // 检查整数类型 🔢