std::views::filter ​

什么是 views::filter ​

std::views::filter 是 C++20 Ranges 库中最常用的范围适配器之一。它接受一个谓词函数,返回一个只包含满足谓词条件的元素的视图。过滤是惰性的——只有在迭代时才判断每个元素是否满足条件。

cpp
auto view = data | std::views::filter(pred);

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <string>
#include <ranges>
#include <algorithm>
#include <map>

// ============================
// 示例1:基本过滤
// ============================

void basic_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 过滤出偶数
    auto evens = data | std::views::filter([](int x) { return x % 2 == 0; });

    std::cout << "偶数: ";
    for (int v : evens) std::cout << v << " ";
    std::cout << std::endl;  // 2 4 6 8 10

    // 过滤出大于 5 的元素
    auto gt5 = data | std::views::filter([](int x) { return x > 5; });

    std::cout << "大于5: ";
    for (int v : gt5) std::cout << v << " ";
    std::cout << std::endl;  // 6 7 8 9 10
}

// ============================
// 示例2:过滤字符串
// ============================

void string_demo() {
    std::vector<std::string> words = {
        "apple", "banana", "cherry", "date", "elderberry", "fig", "grape"
    };

    // 过滤长度大于 4 的单词
    auto long_words = words
        | std::views::filter([](const std::string& s) { return s.size() > 4; });

    std::cout << "长单词: ";
    for (const auto& w : long_words) std::cout << w << " ";
    std::cout << std::endl;

    // 过滤以 'a' 开头的单词
    auto a_words = words
        | std::views::filter([](const std::string& s) {
            return !s.empty() && s[0] == 'a';
        });

    std::cout << "a开头: ";
    for (const auto& w : a_words) std::cout << w << " ";
    std::cout << std::endl;
}

// ============================
// 示例3:链式过滤
// ============================

void chain_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 18, 20};

    // 多个过滤条件链式串联
    auto result = data
        | std::views::filter([](int x) { return x % 2 == 0; })    // 偶数
        | std::views::filter([](int x) { return x % 3 == 0; })    // 且是3的倍数
        | std::views::filter([](int x) { return x > 5; });         // 且大于5

    std::cout << "偶数 & 3的倍数 & >5: ";
    for (int v : result) std::cout << v << " ";
    std::cout << std::endl;  // 6 12 18
}

// ============================
// 示例4:filter 与 transform 组合
// ============================

void combo_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 过滤偶数,然后平方
    auto even_squares = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; });

    std::cout << "偶数的平方: ";
    for (int v : even_squares) std::cout << v << " ";
    std::cout << std::endl;  // 4 16 36 64 100
}

// ============================
// 示例5:过滤 map 的元素
// ============================

void map_demo() {
    std::map<std::string, int> scores = {
        {"Alice", 95}, {"Bob", 60}, {"Charlie", 78},
        {"Diana", 88}, {"Eve", 45}
    };

    // 过滤分数大于等于 70 的学生
    auto passing = scores
        | std::views::filter([](const auto& pair) {
            return pair.second >= 70;
        });

    std::cout << "及格学生:" << std::endl;
    for (const auto& [name, score] : passing) {
        std::cout << "  " << name << ": " << score << std::endl;
    }
}

// ============================
// 示例6:通过 filter_view 修改元素
// ============================

void modify_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // filter_view 的迭代器指向原始元素——可以修改
    auto evens = data | std::views::filter([](int x) { return x % 2 == 0; });

    // 把所有偶数翻倍
    for (int& v : evens) {
        v *= 2;
    }

    std::cout << "修改后: ";
    for (int v : data) std::cout << v << " ";
    std::cout << std::endl;  // 1 4 3 8 5 12 7 16 9 20
}

// ============================
// 示例7:与 iota 配合无限序列过滤
// ============================

void infinite_demo() {
    // 从无限序列中过滤出能被 7 整除的数,取前 5 个
    auto result = std::views::iota(1)
        | std::views::filter([](int x) { return x % 7 == 0; })
        | std::views::take(5);

    std::cout << "前5个7的倍数: ";
    for (int v : result) std::cout << v << " ";
    std::cout << std::endl;  // 7 14 21 28 35
}

int main() {
    std::cout << "=== 基本过滤 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 字符串过滤 ===" << std::endl;
    string_demo();

    std::cout << "\n=== 链式过滤 ===" << std::endl;
    chain_demo();

    std::cout << "\n=== 组合操作 ===" << std::endl;
    combo_demo();

    std::cout << "\n=== map 过滤 ===" << std::endl;
    map_demo();

    std::cout << "\n=== 修改元素 ===" << std::endl;
    modify_demo();

    std::cout << "\n=== 无限序列 ===" << std::endl;
    infinite_demo();

    return 0;
}

filter_view 的范围类别 ​

filter_view 的范围类别取决于底层范围,但有限制:

底层范围类别filter_view 的类别
contiguous_rangebidirectional_range(降级)
random_access_rangebidirectional_range(降级)
bidirectional_rangebidirectional_range
forward_rangeforward_range
input_rangeinput_range

filter_view 最高只能是 bidirectional_range,因为不能跳过被过滤掉的元素做随机访问。

适用场景 ​

  • 从集合中筛选满足条件的元素
  • 与 transform 组合做过滤-变换管道
  • 过滤 map/set 中的特定键值对
  • 通过过滤视图修改满足条件的元素
  • 惰性过滤——数据量大时避免创建中间容器

常见问题 ​

filter_view 会缓存 begin() 的结果吗?

会。对于 forward_range 及以上的底层范围,filter_view 会缓存第一次 begin() 的结果。这意味着如果底层数据在 begin() 调用后发生了变化,缓存可能不一致。

filter 后的视图还是 random_access 吗?

不是。filter_view 最多是 bidirectional_range,因为过滤后元素不再连续,无法 O(1) 跳到第 n 个满足条件的元素。

谓词会被调用多少次?

每次迭代一个元素时,谓词被调用一次。多次遍历会多次调用谓词。filter_view 不缓存过滤结果。

注意事项 ​

  • filter_view 会降低范围类别(最高 bidirectional)
  • begin() 结果会被缓存,底层数据变化后应重建视图
  • filter_view 不是 sized_range(无法 O(1) 获取过滤后的元素个数)
  • 谓词应该是无副作用的纯函数(filter_view 可能多次调用谓词)
  • 可以通过 filter_view 的迭代器修改底层元素

总结 ​

std::views::filter 是 Ranges 库中最常用的适配器,用于从范围中惰性地筛选满足谓词的元素。它不分配内存、不复制数据,通过迭代器指向底层范围的原始元素。filter_view 会缓存 begin() 结果,但不缓存过滤后的元素。需要注意的是,filter 会把范围类别降到最多 bidirectional,并且不是 sized_range。