std::views::take 与 std::views::drop ​

什么是 take 和 drop ​

std::views::take 和 std::views::drop 是 C++20 Ranges 库中用于截取范围片段的适配器。

  • take(n):取范围的前 n 个元素
  • drop(n):跳过范围的前 n 个元素,返回剩余部分

它们还有带谓词的变体:

  • take_while(pred):从头开始取,直到谓词不满足为止
  • drop_while(pred):从头开始跳过,直到谓词不满足为止

基本示例 ​

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

// ============================
// 示例1:take 基本用法
// ============================

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

    // 取前 5 个元素
    auto first_five = data | std::views::take(5);

    std::cout << "前5个: ";
    for (int v : first_five) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5

    // 如果 n 大于范围大小,取全部
    auto all = data | std::views::take(100);

    std::cout << "take(100): ";
    for (int v : all) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5 6 7 8 9 10

    // take(0) 返回空视图
    auto empty = data | std::views::take(0);
    std::cout << "take(0) 是否为空: " << std::boolalpha
              << std::ranges::empty(empty) << std::endl;
}

// ============================
// 示例2:drop 基本用法
// ============================

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

    // 跳过前 3 个元素
    auto after_three = data | std::views::drop(3);

    std::cout << "跳过前3个: ";
    for (int v : after_three) std::cout << v << " ";
    std::cout << std::endl;  // 4 5 6 7 8 9 10

    // 如果 n 大于范围大小,返回空视图
    auto empty = data | std::views::drop(100);
    std::cout << "drop(100) 是否为空: " << std::boolalpha
              << std::ranges::empty(empty) << std::endl;
}

// ============================
// 示例3:take 和 drop 组合实现切片
// ============================

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

    // 取下标 [3, 7) 的元素——先跳过前 3 个,再取 4 个
    auto slice = data | std::views::drop(3) | std::views::take(4);

    std::cout << "切片 [3,7): ";
    for (int v : slice) std::cout << v << " ";
    std::cout << std::endl;  // 3 4 5 6

    // 取最后 3 个元素
    auto last_three = data | std::views::drop(data.size() - 3);

    std::cout << "最后3个: ";
    for (int v : last_three) std::cout << v << " ";
    std::cout << std::endl;  // 7 8 9
}

// ============================
// 示例4:take_while 和 drop_while
// ============================

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

    // take_while:从头开始取偶数,遇到第一个奇数就停止
    auto leading_evens = data
        | std::views::take_while([](int x) { return x % 2 == 0; });

    std::cout << "开头的偶数: ";
    for (int v : leading_evens) std::cout << v << " ";
    std::cout << std::endl;  // 2 4 6

    // drop_while:跳过开头的偶数
    auto after_evens = data
        | std::views::drop_while([](int x) { return x % 2 == 0; });

    std::cout << "跳过开头偶数: ";
    for (int v : after_evens) std::cout << v << " ";
    std::cout << std::endl;  // 1 3 8 10
}

// ============================
// 示例5:与其他适配器组合
// ============================

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

    // 过滤偶数,取前 3 个
    auto first_3_evens = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::take(3);

    std::cout << "前3个偶数: ";
    for (int v : first_3_evens) std::cout << v << " ";
    std::cout << std::endl;  // 2 4 6

    // 变换后跳过前 2 个
    auto skip_2_squares = data
        | std::views::transform([](int x) { return x * x; })
        | std::views::drop(2);

    std::cout << "跳过前2个平方数: ";
    for (int v : skip_2_squares) std::cout << v << " ";
    std::cout << std::endl;  // 9 16 25 36 49 64 81 100
}

// ============================
// 示例6:无限序列截取
// ============================

void infinite_demo() {
    // 从无限序列中取前 10 个
    auto first_10 = std::views::iota(1) | std::views::take(10);

    std::cout << "前10个自然数: ";
    for (int v : first_10) std::cout << v << " ";
    std::cout << std::endl;

    // 从无限序列中跳过前 100 个,取 5 个
    auto range_101_105 = std::views::iota(1)
        | std::views::drop(100)
        | std::views::take(5);

    std::cout << "101-105: ";
    for (int v : range_101_105) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例7:字符串处理
// ============================

void string_demo() {
    std::string text = "Hello, World! This is C++20 Ranges.";

    // 取前 13 个字符
    auto prefix = text | std::views::take(13);
    std::cout << "前缀: ";
    for (char c : prefix) std::cout << c;
    std::cout << std::endl;

    // 跳过开头的非空格字符
    auto after_first_word = text
        | std::views::drop_while([](char c) { return c != ' '; })
        | std::views::drop(1);  // 跳过空格本身

    std::cout << "去掉第一个单词: ";
    for (char c : after_first_word) std::cout << c;
    std::cout << std::endl;
}

int main() {
    std::cout << "=== take ===" << std::endl;
    take_demo();

    std::cout << "\n=== drop ===" << std::endl;
    drop_demo();

    std::cout << "\n=== 切片 ===" << std::endl;
    slice_demo();

    std::cout << "\n=== while 变体 ===" << std::endl;
    while_demo();

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

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

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

    return 0;
}

四个适配器对比 ​

适配器作用参数示例
views::take(n)取前 n 个元素数量data | take(3) → 前3个
views::drop(n)跳过前 n 个数量data | drop(3) → 第4个起
views::take_while(pred)取满足条件的前缀谓词遇到不满足条件的就停
views::drop_while(pred)跳过满足条件的前缀谓词跳到第一个不满足条件的

范围类别保留情况 ​

适配器保留范围类别sized_range
take保留(最高 contiguous)是
drop保留(最高 contiguous)是
take_while最高 bidirectional否
drop_while保留(最高 contiguous)否

适用场景 ​

  • 分页:drop(page * size) | take(size)
  • 切片:drop(start) | take(end - start)
  • 截断无限序列
  • 跳过文件头部(如 CSV 的标题行)
  • 取数据的前 N 条记录

常见问题 ​

take(n) 中 n 大于范围大小会怎样?

不会出错,take 会返回整个范围。行为类似 min(n, size)。

drop(n) 中 n 大于范围大小会怎样?

不会出错,drop 会返回一个空视图。

take_while 和 filter 有什么区别?

take_while 只看前缀——遇到第一个不满足条件的元素就停止,后面即使有满足条件的元素也不会返回。filter 会遍历整个范围,返回所有满足条件的元素。

drop_while 的 begin() 会被缓存吗?

会。对于 forward_range 及以上的底层范围,drop_while_view 会缓存第一次 begin() 的结果。

注意事项 ​

  • take 和 drop 的 n 是非负整数
  • take_while 一旦遇到不满足条件的元素就永久停止
  • drop_while 的 begin() 结果会被缓存
  • 对 sized_range 使用 take/drop 时,编译器可以优化为指针算术
  • take_while 不是 sized_range(无法提前知道满足条件的元素个数)

总结 ​

take 和 drop 是范围切片的基本工具——take(n) 取前 n 个元素,drop(n) 跳过前 n 个元素。两者组合可以实现任意位置的切片。take_while 和 drop_while 是谓词版本,根据条件而不是固定数量来切分范围。这四个适配器都是惰性的,不分配内存。take 对于截断无限序列特别有用——配合 iota 可以生成任意长度的数列。