函数组合：管道操作、compose函数、链式调用

函数组合，说白了就是把多个小函数串起来，让数据像流水一样经过它们。我刚开始学C++函数式编程时，觉得这东西花里胡哨的，直到有一次重构一个数据处理模块——好家伙，嵌套了七八层循环加条件判断，改一个逻辑得翻半天。后来用管道操作重写，代码量砍了一半，可读性翻了三倍。

你想想看，我们写代码最怕什么？怕逻辑散落一地，怕改一处牵全身。函数组合就是解决这个问题的——把每个处理步骤拆成独立的小函数，然后用管道或compose把它们串成一条链。每个环节只管自己的事，互不干扰。

管道操作：从左到右的数据流

管道操作，就是数据从左往右流。先执行第一个函数，结果传给第二个，再传给第三个……直到最终结果。C++里没有原生的管道运算符，但我们可以自己实现一个简单的版本。

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

// 管道操作符：把左值传给右函数
template<typename T, typename F>
auto operator|(T&& value, F func) {
    return func(std::forward<T>(value));
}

// 示例：数据处理管道
int main() {
    std::vector<int> data = {3, 1, 4, 1, 5, 9, 2, 6};
    
    // 传统写法：嵌套调用，从内往外读
    auto result1 = filter(
        map(data, [](int x) { return x * 2; }),
        [](int x) { return x > 5; }
    );
    
    // 管道写法：从左往右读，逻辑清晰
    auto result2 = data 
        | [](std::vector<int> v) { 
            std::sort(v.begin(), v.end()); 
            return v; 
          }
        | [](std::vector<int> v) {
            std::vector<int> out;
            std::copy_if(v.begin(), v.end(), 
                std::back_inserter(out), 
                [](int x) { return x % 2 == 0; });
            return out;
          }
        | [](std::vector<int> v) {
            int sum = 0;
            for (auto x : v) sum += x;
            return sum;
          };
    
    std::cout << "管道结果: " << result2 << std::endl;
    return 0;
}

我个人习惯用管道操作，因为读代码时眼睛从左往右扫，跟阅读顺序一致。你想想看，嵌套调用你得从最里面往外读，脑子得来回转，累不累？

小技巧：管道操作符重载时注意完美转发，避免不必要的拷贝。我项目中就吃过这个亏——数据量一大，拷贝开销直接让性能腰斩。

compose函数：从右到左的数学风格

compose跟管道相反，它是从右往左执行的。数学上写 f∘g(x) 就是先算 g(x)，再算 f(g(x))。C++里实现compose，本质上就是返回一个lambda，内部按顺序调用。

#include <iostream>
#include <functional>

// 二元compose
template<typename F, typename G>
auto compose(F f, G g) {
    return [f, g](auto&&... args) {
        return f(g(std::forward<decltype(args)>(args)...));
    };
}

// 可变参数compose（支持多个函数）
template<typename F, typename... Rest>
auto compose(F f, Rest... rest) {
    return [f, rest...](auto&&... args) {
        return f(compose(rest...)(std::forward<decltype(args)>(args)...));
    };
}

// 终止条件：单个函数直接返回
template<typename F>
auto compose(F f) {
    return f;
}

int main() {
    auto add1 = [](int x) { return x + 1; };
    auto mul2 = [](int x) { return x * 2; };
    auto sub3 = [](int x) { return x - 3; };
    
    // compose: 先sub3, 再mul2, 最后add1
    // 数学上: add1 ∘ mul2 ∘ sub3
    auto composed = compose(add1, mul2, sub3);
    
    // 计算: add1(mul2(sub3(10)))
    // sub3(10) = 7
    // mul2(7) = 14
    // add1(14) = 15
    std::cout << "compose结果: " << composed(10) << std::endl;
    
    return 0;
}

嗯，这里要注意：compose的阅读顺序跟执行顺序相反。如果你习惯数学函数复合的写法，compose很自然。但我个人在实际项目中更常用管道，因为团队里不是每个人都熟悉数学符号，管道从左到右更直观。

核心区别：
  • 管道（|）：从左到右，数据先经过A再经过B。读代码时跟执行顺序一致。
  • compose：从右到左，先执行最右边的函数。数学风格，适合理论推导。

链式调用：面向对象的函数组合

链式调用大家应该不陌生，STL里的iostream就是典型例子：cout << "hello" << " world"。在函数式编程里，我们可以让每个函数返回一个可继续调用的对象，从而实现链式风格。

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

class QueryBuilder {
    std::vector<std::string> conditions;
    std::string table;
    std::vector<std::string> orderBy_;
    
public:
    QueryBuilder& from(const std::string& t) {
        table = t;
        return *this;  // 返回引用，支持链式
    }
    
    QueryBuilder& where(const std::string& cond) {
        conditions.push_back(cond);
        return *this;
    }
    
    QueryBuilder& orderBy(const std::string& field) {
        orderBy_.push_back(field);
        return *this;
    }
    
    std::string build() const {
        std::string sql = "SELECT * FROM " + table;
        if (!conditions.empty()) {
            sql += " WHERE ";
            for (size_t i = 0; i < conditions.size(); ++i) {
                if (i > 0) sql += " AND ";
                sql += conditions[i];
            }
        }
        if (!orderBy_.empty()) {
            sql += " ORDER BY ";
            for (size_t i = 0; i < orderBy_.size(); ++i) {
                if (i > 0) sql += ", ";
                sql += orderBy_[i];
            }
        }
        return sql;
    }
};

int main() {
    // 链式调用：每个函数返回this
    std::string query = QueryBuilder()
        .from("users")
        .where("age > 18")
        .where("status = 'active'")
        .orderBy("name")
        .build();
    
    std::cout << query << std::endl;
    // 输出: SELECT * FROM users WHERE age > 18 AND status = 'active' ORDER BY name
    
    return 0;
}

链式调用的好处是——你写代码时就像在填表格，一步步往下走，IDE还能自动提示下一步能调什么函数。我曾经在项目中用链式调用重构了一个配置解析模块，原来200多行的switch-case，变成了20多行的链式调用，每个环节一目了然。

避坑指南：链式调用里每个函数必须返回引用（或指针），不能返回临时对象。我曾经犯过这个错——返回了值拷贝，结果链式调用到第三步时发现操作的是副本，原始对象纹丝不动。排查了半天，最后发现是忘了加&。

三种风格的对比与选择

风格 执行顺序 适用场景 可读性 实现复杂度
管道操作 从左到右 数据处理流水线、流式处理 高（跟阅读顺序一致） 中（需重载运算符）
compose 从右到左 数学计算、函数复合 中（需理解数学符号） 高（可变参数模板）
链式调用 从左到右 构建器模式、配置组装 高（IDE友好） 低（返回*this）

我个人建议：团队里如果大家函数式编程经验不多，优先用管道或链式调用。compose虽然数学上优雅，但读代码的人得从右往左看，容易晕。我项目中就遇到过——新同事看到compose代码，愣了半天问「这顺序是不是写反了？」

知识体系图

函数组合三种风格对比 管道操作 数据从左到右流动 A | B | C 顺序执行 需重载 operator| 适合数据处理流水线 数据流方向 输入 → A → B → C → 输出 compose 从右到左执行 f ∘ g ∘ h 先执行h 可变参数模板实现 适合数学函数复合 执行顺序 输入 → h → g → f → 输出 链式调用 每个函数返回 *this 对象自身不断被操作 IDE自动提示友好 适合构建器模式 调用链 obj.A().B().C() 选择建议：团队经验少用管道/链式，数学背景强用compose

实际项目中的组合技巧

我在项目中遇到过这样一个场景：需要从多个数据源拉取数据，然后做清洗、转换、聚合、输出。如果用传统写法，就是一堆for循环加if判断，改一个逻辑得动好几处。

后来我用管道操作重写了核心流程：

// 实际项目中的数据处理管道
auto pipeline = [](const std::vector<RawData>& raw) {
    return raw
        | validate_input      // 第一步：校验输入
        | clean_duplicates    // 第二步：去重
        | transform_format    // 第三步：格式转换
        | aggregate_by_key    // 第四步：按key聚合
        | sort_results        // 第五步：排序
        | format_output;      // 第六步：格式化输出
};

每个步骤都是一个独立的函数，可以单独测试、单独替换。后来需求变了，要在聚合之前加一个过滤步骤——我只需要在管道里插入一行，其他代码纹丝不动。这就是函数组合的魅力：高内聚、低耦合，改一处不影响全局。

核心原则：
  • 每个函数只做一件事，做好一件事
  • 函数的输入输出类型要匹配，否则组合不起来
  • 纯函数优先——不修改外部状态，只依赖输入参数
  • 组合顺序就是执行顺序，想清楚再动手

说白了，函数组合就是把大问题拆成小问题，再把小问题的答案串起来。你想想看，我们写代码不就是在做这件事吗？只不过函数组合给了你一套更优雅、更规范的做法。

嗯，最后提醒一句：别为了组合而组合。如果逻辑本身只有两步，直接写两个函数调用就行，没必要硬套管道或compose。工具是为人服务的，别反过来被工具绑架。

← 上一章 📖 返回目录 下一章 →