// 定義一個簡單的乘法 Lambda ??
auto multiply = [](float x, float y) { 
    // 計算兩個浮點(diǎn)數(shù)的乘積 ??
    return x * y;    
}; 

// 調(diào)用 Lambda 進(jìn)行計算 ??
float result = multiply(
    2.5f,  // 第一個操作數(shù)
    3.0f   // 第二個操作數(shù)
);  // 結(jié)果是 7.5

// 這個 Lambda 比較固執(zhí) ??
// 只能處理 float 類型的數(shù)據(jù)
// 就像個不懂變通的小朋友 ??

// 創(chuàng)建一個通用的連接器 Lambda ??
auto concat = [](auto a, auto b) { 
    // 使用 + 運(yùn)算符連接兩個參數(shù) ?
    return a + b;    
}; 

// 字符串連接示例 ??
auto str = concat(
    "Hello",  // 第一個字符串
    "World"   // 第二個字符串
);  // 結(jié)果: HelloWorld

// 數(shù)字相加示例 ??
auto sum = concat(
    10,  // 第一個數(shù)字
    20   // 第二個數(shù)字
);  // 結(jié)果: 30

// 創(chuàng)建一個類型安全的比較器 Lambda ??
auto compare = [](
    auto x,         // 第一個參數(shù)
    decltype(x) y   // 第二個參數(shù),必須和x同類型
) {
    // 檢查兩個值是否相等 ?
    return x == y;   
}; 

// 測試相同類型的比較 ?
bool ok = compare(
    10,    // 第一個整數(shù)
    10     // 第二個整數(shù)
);  // 結(jié)果為 true

// 下面的代碼會編譯失敗 ?
// bool nope = compare(
//     10,     // 整數(shù)類型
//     10.5    // 浮點(diǎn)類型,類型不匹配!
// ); 

auto max = []<typename T>(T a, T b) {
    return a > b ? a : b;  // 模板讓它更專業(yè)了
}; 
int result = max(42, 24);  // 這個可以! ?
// int err = max(42, 24.5);  // 不同類型?不行! ?

// 使用 auto 的舊方式 ??
auto oldWay = [](auto x, auto y) {
    // 參數(shù)類型可能不一致,存在潛在風(fēng)險 ??
    return x + y;    
};

// 使用模板參數(shù)的新方式 ?
auto newWay = []<typename T>
    (T x, T y) {
    // 編譯期類型檢查,保證類型安全 ???
    static_assert(
        std::is_arithmetic_v<T>, 
        "Must be numeric type!"
    );
    
    // 保證參數(shù)類型一致 ?
    return x + y;    
};

// 創(chuàng)建一個通用的打印容器函數(shù) ???
auto printContainer = [](const auto& c) { 
    // 遍歷容器中的每個元素 ??
    for(const auto& elem : c) {
        // 打印當(dāng)前元素,添加空格分隔 ?
        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()
    );
}; 

// 創(chuàng)建一個測試用的整數(shù)向量 ??
std::vector<int> numbers = {
    4, 2, 7, 1, 9
};

// 調(diào)用 Lambda 查找最大值 ?
int max = findMax(numbers);  // 返回 9

// 創(chuàng)建一個只接受浮點(diǎn)數(shù)的求和函數(shù) ??
auto sumNumbers = []<std::floating_point T>
    (conststd::vector<T>& vec) {
    // 使用 accumulate 計算總和
    // 初始值設(shè)為 T{} (即 0.0) ?
    returnstd::accumulate(
        vec.begin(),  // 從開始位置
        vec.end(),    // 到結(jié)束位置
        T{}           // 初始值為 0
    );
}; 

// 創(chuàng)建一個測試用的浮點(diǎn)數(shù)向量 ??
std::vector<double> doubles = {
    1.2,  // 第一個數(shù)
    3.4,  // 第二個數(shù)
    5.6   // 第三個數(shù)
};

// 調(diào)用 Lambda 計算總和 ?
double sum = sumNumbers(doubles);  
// 結(jié)果是 10.2 = 1.2 + 3.4 + 5.6 ??

// 創(chuàng)建一個完美轉(zhuǎn)發(fā)的 Lambda ??
auto magicForward = []<typename T>
    // 使用萬能引用接收參數(shù) ??
    (T&& arg) {
    // 完美轉(zhuǎn)發(fā)參數(shù),保持值類別不變 ?
    returnstd::forward<T>(arg);
};

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

// 轉(zhuǎn)發(fā)左值 ??
auto& lref = magicForward(str);

// 轉(zhuǎn)發(fā)右值 ??
auto rval = magicForward(
    std::string("world")
);

// 創(chuàng)建一個挑剔的排序器 Lambda ??
auto pickySorter = []<typename T>
    // 容器參數(shù),使用引用避免拷貝 ??
    (T& container) 
    // 要求容器支持隨機(jī)訪問 ?
    requiresstd::ranges::random_access_range<T> 
{
    // 使用 ranges 庫進(jìn)行排序 ??
    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 不支持隨機(jī)訪問!

// 創(chuàng)建一個計算階乘的天才 Lambda ??
auto mathGenius = []<typename T>(T n) -> T {
    // 檢查是否為整數(shù)類型 ??
    ifconstexpr (std::is_integral_v<T>) {
        // 遞歸計算階乘 ?
        // 基本情況:當(dāng) n <= 1 時返回 1
        if (n <= 1) {
            return1;
        }
        
        // 遞歸情況:n * (n-1)! 
        return n * mathGenius(n - 1);
    } else {
        // 如果不是整數(shù)類型就報錯 ??
        static_assert(
            std::is_integral_v<T>,
            "只能計算整數(shù)的階乘哦～ ??"
        );
    }
};

// 使用示例 ?
int result = mathGenius(5);  // 計算 5!
// 結(jié)果是 120 = 5 * 4 * 3 * 2 * 1

// 以下代碼會編譯失敗 ?
// double wrong = mathGenius(5.5); 
// 錯誤:浮點(diǎn)數(shù)不能計算階乘!

// ? 糟糕的寫法:每次循環(huán)都創(chuàng)建新的 Lambda
for (int i = 0; i < n; ++i) {
    // 每次循環(huán)都要創(chuàng)建新對象,太浪費(fèi)了! ??
    auto lambda = []<typename T>
        (T x) { 
            return x * x; 
        };
    
    // 調(diào)用 lambda 計算平方
    result += lambda(i);  
}

// ? 推薦寫法:在循環(huán)外定義 Lambda
// 只創(chuàng)建一次 Lambda 對象 ??
auto lambda = []<typename T>
    (T x) {
        // 計算并返回平方值
        return x * x;
    };

// 循環(huán)中重復(fù)使用同一個 Lambda
for (int i = 0; i < n; ++i) {
    // 直接使用已創(chuàng)建的 lambda
    result += lambda(i);  // 性能更好! ??
}

// 創(chuàng)建一個類型偵探 Lambda ??
auto sherlock = []<typename T>
    (T value) {
    // 在編譯期進(jìn)行類型檢查 ??
    static_assert(
        sizeof(T) > 0, 
        "類型檢查: "
        __PRETTY_FUNCTION__
    ); 
    
    // 打印運(yùn)行時的類型信息 ??
    std::cout
        << "發(fā)現(xiàn)類型: "
        << typeid(T).name() 
        << '\n'; 
    
    // 返回原始值 ?
    return value;
};

// 使用示例 
int num = 42;
sherlock(num);      // 檢查整數(shù)類型 ??