如何在C++中实现一个简单的函数式map和filter？Ranges与Lambda怎么用？

在C++中结合Ranges和Lambda实现函数式的map和filter操作，能够大幅简化对容器元素的遍历处理逻辑，让代码更贴近函数式编程的简洁风格。下面我们从基础原理到具体实现逐步展开说明。

map和filter的核心作用

map操作的核心是对容器中的每个元素应用一个转换函数，得到一个新的元素集合，新集合的大小和原容器一致，只是每个元素都经过了指定的转换。filter操作则是根据指定的条件筛选容器中的元素，得到的新集合是原集合的子集，仅包含满足条件的元素。

在传统的C++开发中，我们通常需要手写for循环来完成这两类操作，代码冗余度较高。而借助Ranges库和Lambda表达式，我们可以用更简洁的方式实现对应的功能。

Ranges与Lambda基础介绍

Ranges库

C++20引入的Ranges库提供了一套统一的容器操作接口，支持链式调用，能够直接对容器进行各种变换和筛选操作，不需要像以前那样频繁使用迭代器。Ranges的核心优势是让容器操作的逻辑更直观，代码可读性更高。

Lambda表达式

Lambda表达式是C++11引入的匿名函数特性，允许我们在需要函数的地方直接定义简短的函数逻辑，不需要单独定义函数名。基本语法为[] (参数列表) { 函数体 }，其中方括号内的部分是捕获列表，用来指定Lambda可以访问的外部变量。

自定义实现简单的map和filter

我们可以基于模板和迭代器，自定义两个通用的函数，分别实现map和filter的功能，这样即使在不支持Ranges的旧版本C++中也能使用。

自定义map实现

下面的代码实现了一个通用的map函数，接收一个容器和一个转换函数，返回转换后的新容器：

#include <iostream>
#include <vector>
#include <type_traits>

// 自定义map函数，支持任意容器类型和转换函数
template <typename Container, typename Func>
auto my_map(const Container& container, Func func) {
    // 获取原容器元素的类型
    using ValueType = typename Container::value_type;
    // 推导转换后元素的类型
    using ResultType = std::invoke_result_t<Func, ValueType>;
    // 创建结果容器，类型和原容器一致，元素类型为转换后的类型
    std::vector<ResultType> result;
    result.reserve(container.size());
    // 遍历原容器，对每个元素应用转换函数
    for (const auto& item : container) {
        result.push_back(func(item));
    }
    return result;
}

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    // 使用Lambda作为转换函数，将每个元素乘以2
    auto doubled = my_map(nums, [](int x) { return x * 2; });
    for (int num : doubled) {
        std::cout << num << " ";
    }
    // 输出：2 4 6 8 10
    return 0;
}

自定义filter实现

下面的代码实现了一个通用的filter函数，接收一个容器和一个筛选条件函数，返回筛选后的新容器：

#include <iostream>
#include <vector>

// 自定义filter函数，支持任意容器类型和筛选条件
template <typename Container, typename Func>
auto my_filter(const Container& container, Func func) {
    using ValueType = typename Container::value_type;
    std::vector<ValueType> result;
    // 遍历原容器，将满足条件的元素加入结果容器
    for (const auto& item : container) {
        if (func(item)) {
            result.push_back(item);
        }
    }
    return result;
}

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
    // 使用Lambda作为筛选条件，筛选偶数
    auto even_nums = my_filter(nums, [](int x) { return x % 2 == 0; });
    for (int num : even_nums) {
        std::cout << num << " ";
    }
    // 输出：2 4 6
    return 0;
}

使用标准Ranges配合Lambda实现操作

如果开发环境支持C++20及以上版本，可以直接使用标准库中的Ranges组件，配合Lambda更简洁地完成map和filter操作，不需要自定义函数。

Ranges实现map操作

使用std::ranges::transform可以完成map的功能，配合Lambda指定转换逻辑：

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

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    std::vector<int> result;
    // 使用ranges::transform完成map操作，将每个元素乘以3
    std::ranges::transform(nums, std::back_inserter(result), [](int x) { return x * 3; });
    for (int num : result) {
        std::cout << num << " ";
    }
    // 输出：3 6 9 12 15
    return 0;
}

Ranges实现filter操作

使用std::ranges::filter_view可以直接筛选出满足条件的元素，支持链式调用：

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8};
    // 使用filter_view筛选大于4的元素，配合Lambda定义条件
    auto filtered = nums | std::ranges::views::filter([](int x) { return x > 4; });
    for (int num : filtered) {
        std::cout << num << " ";
    }
    // 输出：5 6 7 8
    return 0;
}

Ranges链式调用实现map+filter组合操作

Ranges的一大优势是支持链式调用，我们可以同时完成map和filter操作，比如先筛选偶数，再将每个偶数乘以2：

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
    // 链式调用：先筛选偶数，再将每个元素乘以2
    auto result = nums 
        | std::ranges::views::filter([](int x) { return x % 2 == 0; })
        | std::ranges::views::transform([](int x) { return x * 2; });
    for (int num : result) {
        std::cout << num << " ";
    }
    // 输出：4 8 12
    return 0;
}

两种实现方式的对比

我们可以通过下面的表格对比自定义实现和标准Ranges实现的特点：

实际开发中可以根据项目的C++版本要求选择合适的实现方式，如果版本允许，优先使用Ranges的方式，代码会更简洁易维护。

C++mapfilterLambdaranges修改时间：2026-06-22 22:51:55