高阶函数：接受Lambda作为参数、返回Lambda的函数

高阶函数这个词，听起来挺唬人的。其实说白了，就是「把函数当成普通变量来用」。

我刚开始学C++那会儿，总觉得函数就是函数，变量就是变量，两者井水不犯河水。直到我真正理解了高阶函数，才意识到——函数也可以像int、string一样，传来传去，甚至作为返回值。

Lambda表达式的出现，让高阶函数在C++里变得异常顺手。你想想看，以前要传一个函数，得先定义一个函数对象或者函数指针，麻烦得很。现在直接写个Lambda扔进去，干净利落。

什么是高阶函数？

高阶函数，就是满足以下任一条件的函数：

• 接受函数作为参数——比如std::sort的第三个参数
• 返回一个函数——比如一个工厂函数，根据配置生成不同的处理逻辑

这两种情况，在C++里都能用Lambda完美配合。

场景一：接受Lambda作为参数

这是最常见的高阶函数用法。标准库里的算法，几乎都是这个模式。

#include <iostream>
#include <vector>
#include <algorithm>

// 一个高阶函数，接受Lambda作为参数
template <typename Func>
void processNumbers(const std::vector<int>& nums, Func processor) {
    for (int n : nums) {
        processor(n);
    }
}

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    
    // 传入一个Lambda
    processNumbers(data, [](int x) {
        std::cout << x * x << " ";
    });
    // 输出: 1 4 9 16 25
    
    return 0;
}

我在项目中遇到过类似的需求——需要遍历一个容器，但具体对每个元素做什么，得由调用方决定。用高阶函数+Lambd，代码立马变得灵活起来。

场景二：返回Lambda的函数

这个就更有意思了。函数可以「生产」出新的函数。

#include <iostream>

// 返回一个Lambda的高阶函数
auto makeMultiplier(int factor) {
    return [factor](int x) {
        return x * factor;
    };
}

int main() {
    auto doubler = makeMultiplier(2);
    auto tripler = makeMultiplier(3);
    
    std::cout << doubler(5) << std::endl;  // 10
    std::cout << tripler(5) << std::endl;  // 15
    
    return 0;
}

你看，makeMultiplier返回了一个Lambda，这个Lambda「记住」了factor的值。这就是闭包的威力。

我曾经用这个模式写过一套配置驱动的数据处理管线。根据不同的配置参数，生成不同的处理函数，然后统一塞到一个vector里依次执行。代码量减少了一半，可读性反而提升了。

场景三：高阶函数与STL算法

STL算法是高阶函数的最佳舞台。我们来看看实际项目中怎么用。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

struct Task {
    std::string name;
    int priority;
    bool completed;
};

int main() {
    std::vector<Task> tasks = {
        {"写报告", 3, false},
        {"修Bug", 5, true},
        {"开会", 2, false},
        {"代码审查", 4, false}
    };
    
    // 高阶函数：std::sort接受Lambda
    std::sort(tasks.begin(), tasks.end(), 
        [](const Task& a, const Task& b) {
            return a.priority > b.priority;  // 按优先级降序
        });
    
    // 高阶函数：std::copy_if接受Lambda
    std::vector<Task> urgentTasks;
    std::copy_if(tasks.begin(), tasks.end(), 
        std::back_inserter(urgentTasks),
        [](const Task& t) {
            return t.priority >= 4 && !t.completed;
        });
    
    // 高阶函数：std::for_each接受Lambda
    std::for_each(urgentTasks.begin(), urgentTasks.end(),
        [](const Task& t) {
            std::cout << "紧急: " << t.name << std::endl;
        });
    
    return 0;
}

这段代码里，三个STL算法都是高阶函数。每个Lambda都只做一件事，清晰得很。

高阶函数的组合用法

高阶函数可以嵌套使用，形成函数组合。这是函数式编程的核心思想之一。

#include <iostream>
#include <functional>

// 组合两个函数
template <typename F, typename G>
auto compose(F f, G g) {
    return [f, g](auto x) {
        return f(g(x));
    };
}

int main() {
    auto addOne = [](int x) { return x + 1; };
    auto doubleIt = [](int x) { return x * 2; };
    
    // 先double再加1
    auto addOneAfterDouble = compose(addOne, doubleIt);
    std::cout << addOneAfterDouble(3) << std::endl;  // 7
    
    // 先加1再double
    auto doubleAfterAddOne = compose(doubleIt, addOne);
    std::cout << doubleAfterAddOne(3) << std::endl;  // 8
    
    return 0;
}

compose函数接受两个Lambda，返回一个新的Lambda。这个新Lambda内部调用了f(g(x))。说白了，就是把两个小功能拼成一个新功能。

避坑指南

我踩过不少高阶函数的坑，分享几个印象深刻的：

• Lambda的生命周期——返回Lambda时，如果捕获了指针或引用，调用时可能已经悬空。我曾经在回调系统中犯过这个错，排查了一整个下午。
• 模板代码膨胀——每个不同的Lambda都会实例化一份模板代码。如果Lambda很多，编译后的二进制会变大。不过现代链接器优化得不错，一般不用太担心。
• 可读性平衡——高阶函数虽好，但别滥用。如果一个Lambda超过10行，或者嵌套超过两层，我建议还是拆成具名函数吧。

高阶函数的核心逻辑

下面这张图，帮你理清高阶函数在C++中的运作方式：

这张图展示了高阶函数的两种形式，以及它们在C++中的具体实现方式。左边是概念，右边是代码层面的落地。

总结

高阶函数不是什么高深莫测的东西。它就是让函数也能像数据一样被传递和返回。Lambda让这件事变得特别自然。

我个人习惯在以下场景优先考虑高阶函数：

• 需要对容器做批量操作时
• 需要延迟执行某些逻辑时
• 需要根据配置动态生成行为时

记住一点：高阶函数是为了让代码更简洁、更灵活。如果用了反而变复杂了，那就别硬用。工具是为人服务的，不是反过来。