C++ STL 算法完全指南 - 提升编程效率与代码质量

C++ 标准库的 <algorithm> 提供了大量通用的算法, 用于操作容器, 范围和迭代器. 本文对其做了归纳总结, 并配上代码以供读者了解其功能. 整理不易, 希望您点赞或者收藏, 非常感谢.

本文所有代码均可在此处获取.

编译器要求

本文的代码需要编译器支持 C++23 标准才可以运行. 另外部分示例目前需要使用 Visual Studio(MSVC) 才可以编译通过. 本文示例在如下编译器上面编译通过:

• GCC 14.2
• Clang 18.1.3

批处理操作

• for_each, ranges::for_each: 对范围内的每一个元素执行操作

  std::vector v = {1, 2, 3, 4, 5};
  // for_each
  std::for_each(v.begin(), v.end(), [](int& n) { n *= 2; });
  fmt::println("{}", v);  // [2, 4, 6, 8, 10]
  
  // ranges::for_each (C++20)
  std::ranges::for_each(v, [](int& n) { n = 1; });
  fmt::println("{}", v);  // [1, 1, 1, 1, 1]
  

• for_each_n, ranges::for_each_n (C++17): 对一个序列的前 N 个元素执行操作

  std::vector  v = {1, 2, 3, 4, 5};
  // for_each_n (C++17)
  std::for_each_n(v.begin(), 3, [](int& n) { n = 2; });
  fmt::println("{}", v);  // [2, 2, 2, 1, 1]
  
  // ranges::for_each_n (C++20)
  std::ranges::for_each_n(v.begin(), 2, [](int& n) { n = 3; });
  fmt::println("{}", v);  // [3, 3, 2, 1, 1]
  

搜索操作

这些算法不会修改容器中的元素, 主要用于查询, 统计和范围操作.

检查元素

• all_of, ranges::all_of (C++20): 检查范围内所有元素是否满足条件.

  constexpr std::array v = {1, 2, 3, 4, 5};
  // all_of
  fmt::println("All elements greater than 0: {}",
               std::all_of(v.begin(), v.end(), [](int n) { return n > 0; }));
  // ranges::all_of (C++20)
  fmt::println("All elements greater than 1: {}",
               std::ranges::all_of(v, [](int n) { return n > 1; }));

• any_of, ranges::any_of (C++20): 检查范围内是否存在满足条件的元素.

  constexpr std::array v = {1, 2, 3, 4, 5};
  // any_of
  fmt::println("Any element greater than 4: {}",
               std::any_of(v.begin(), v.end(), [](int n) { return n > 4; }));
  // ranges::any_of (C++20)
  fmt::println("Any element greater than 6: {}",
               std::ranges::any_of(v, [](int n) { return n > 6; }));

• none_of, ranges::none_of (C++20): 检查范围内所有元素是否都不满足条件.

  constexpr std::array v = {1, 2, 3, 4, 5};
  // none_of
  fmt::println("None of the elements greater than 6: {}",
               std::none_of(v.begin(), v.end(), [](int n) { return n > 6; }));
  // ranges::none_of (C++20)
  fmt::println("None of the elements greater than 2: {}",
               std::ranges::none_of(v, [](int n) { return n > 2; }));

查找

• ranges::contains (C++23): 检查范围是否包含指定值.

  std::vector v = {1, 2, 3, 4, 5, 3};
  // ranges::contains (C++23)
  fmt::print("Vector contains 3: {}\n", std::ranges::contains(v, 3));
  // Vector contains 3: true
  

• ranges::contains_subrange (C++23): 检查范围是否包含指定子范围.

  std::vector<int> v = {1, 2, 3, 4, 5, 3};
  std::vector<int> sub_v = {3, 4};
  
  // ranges::contains_subrange (C++23)
  fmt::print("Vector contains sub - range {{3, 4}}: {}\n",
             std::ranges::contains_subrange(v, sub_v));
  // Vector contains sub - range {3, 4}: true
  

• find, ranges::find: 查找第一个等于指定值的元素.

  std::vector<int> v = {1, 2, 3, 4, 5, 3};
  
  // find
  if (auto it = std::find(v.begin(), v.end(), 3); it != v.end()) {
    fmt::print("Found 3 at position: {}\n", std::distance(v.begin(), it));
    // Found 3 at position: 2
  }
  // ranges::find
  if (auto rit = std::ranges::find(v, 3); rit != v.end()) {
    fmt::print("Found 3 at position (ranges): {}\n",
               std::distance(v.begin(), rit));
    // Found 3 at position (ranges): 2
  }

• find_if, ranges::find_if: 查找第一个满足条件的元素.

  std::vector<int> v = {1, 2, 3, 4, 5, 3};
  
  // find_if
  // 查找第一个大于 3 的元素, 第一个大于 3 的元素是 4, 其位置索引是 3
  if (auto it_if =
          std::find_if(v.begin(), v.end(), [](int n) { return n > 3; });
      it_if != v.end()) {
    fmt::print("Found element greater than 3 at position: {}\n",
               std::distance(v.begin(), it_if));
    // Found element greater than 3 at position: 3
  }
  
  // ranges::find_if
  // 使用 ranges 版本查找第一个大于 3 的元素, 结果位置索引同样是 3
  if (auto rit_if = std::ranges::find_if(v, [](int n) { return n > 3; });
      rit_if != v.end()) {
    fmt::print("Found element greater than 3 at position (ranges): {}\n",
               std::distance(v.begin(), rit_if));
    // Found element greater than 3 at position (ranges): 3
  }

• find_if_not, ranges::find_if_not: 查找第一个不满足条件的元素.

  std::vector<int> v = {1, 2, 3, 4, 5, 3};
  // find_if_not
  // 查找第一个不大于 3 的元素, 也就是第一个小于等于 3 的元素, 是 1, 位置索引是0
  if (auto it_if_not =
          std::find_if_not(v.begin(), v.end(), [](int n) { return n > 3; });
      it_if_not != v.end()) {
    fmt::print("Found element not greater than 3 at position: {}\n",
               std::distance(v.begin(), it_if_not));
    // Found element not greater than 3 at position: 0
  }
  
  // ranges::find_if_not
  // 使用 ranges 版本查找第一个不大于 3 的元素, 结果位置索引还是 0
  if (auto rit_if_not =
          std::ranges::find_if_not(v, [](int n) { return n > 3; });
      rit_if_not != v.end()) {
    fmt::print("Found element not greater than 3 at position (ranges): {}\n",
               std::distance(v.begin(), rit_if_not));
    // Found element not greater than 3 at position (ranges): 0
  }

• ranges::find_last (C++23):查找最后一个等于指定值的元素.

  std::vector<int> numbers = {1, 2, 3, 2, 4, 2};
  int target = 2;
  auto result = std::ranges::find_last(numbers, target);
  if (result.begin() != numbers.end()) {
    fmt::println("ranges::find_last: Found 2 at index {}",
                 std::distance(numbers.begin(), result.begin()));
  } else {
    fmt::println("ranges::find_last: Not found");
  }

• ranges::find_last_if (C++23): 查找最后一个满足条件的元素.

  std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
  auto isEven = [](int num) { return num % 2 == 0; };
  auto result = std::ranges::find_last_if(numbers, isEven);
  if (result.begin() != numbers.end()) {
    fmt::println("ranges::find_last_if: Found last even number {} at index {}",
                 *result.begin(),
                 std::distance(numbers.begin(), result.begin()));
    // 预期输出: ranges::find_last_if: Found even number 6 at index 5
  } else {
    fmt::println("ranges::find_last_if: Not found");
  }

• ranges::find_last_if_not (C++23): 查找最后一个不满足条件的元素.

  std::vector<int> numbers = {2, 4, 6, 3, 8, 10};
  auto isEven = [](int num) { return num % 2 == 0; };
  auto result = std::ranges::find_last_if_not(numbers, isEven);
  if (result.begin() != numbers.end()) {
    fmt::println("ranges::find_last_if_not: Found odd number {} at index {}",
                 *result.begin(),
                 std::distance(numbers.begin(), result.begin()));
    // 预期输出: ranges::find_last_if_not: Found odd number 3 at index 3
  } else {
    fmt::println("ranges::find_last_if_not: Not found");
  }

• find_end, ranges::find_end: 查找某个子范围在另一个范围中最后一次出现的位置.

  std::vector<int> mainRange = {1, 2, 3, 4, 1, 2, 3};
  std::vector<int> subRange = {1, 2, 3};
  // 使用 std::find_end
  auto stdResult = std::find_end(mainRange.begin(), mainRange.end(),
                                 subRange.begin(), subRange.end());
  if (stdResult != mainRange.end()) {
    fmt::println("std::find_end: Sub - range found starting at index {}",
                 std::distance(mainRange.begin(), stdResult));
    // 预期输出: std::find_end: Sub - range found starting at index 4
  } else {
    fmt::println("std::find_end: Sub - range not found");
  }
  
  // 使用 std::ranges::find_end
  auto rangesResult = std::ranges::find_end(mainRange, subRange);
  if (!rangesResult.empty()) {
    fmt::println(
        "std::ranges::find_end: Sub - range found starting at index {}",
        std::distance(mainRange.begin(), rangesResult.begin()));
    // 预期输出: std::ranges::find_end: Sub - range found starting at index 4
  } else {
    fmt::println("std::ranges::find_end: Sub - range not found");
  }

• find_first_of, ranges::find_first_of: 查找两个范围中第一个匹配的元素.

  std::vector<int> firstRange = {1, 2, 3, 4, 5};
  std::vector<int> secondRange = {3, 6, 7};
  // 使用 std::find_first_of
  auto stdResult = std::find_first_of(firstRange.begin(), firstRange.end(),
                                      secondRange.begin(), secondRange.end());
  if (stdResult != firstRange.end()) {
    fmt::println("std::find_first_of: Found matching element {} at index {}",
                 *stdResult, std::distance(firstRange.begin(), stdResult));
    // 预期输出: std::find_first_of: Found matching element 3 at index 2
  } else {
    fmt::println("std::find_first_of: No matching element found");
  }
  
  // 使用 std::ranges::find_first_of
  auto rangesResult = std::ranges::find_first_of(firstRange, secondRange);
  if (rangesResult != firstRange.end()) {
    fmt::println(
        "std::ranges::find_first_of: Found matching element {} at index {}",
        *rangesResult, std::distance(firstRange.begin(), rangesResult));
    // 预期输出: std::ranges::find_first_of: Found matching element 3 at index 2
  } else {
    fmt::println("std::ranges::find_first_of: No matching element found");
  }

• adjacent_find, ranges::adjacent_find: 查找范围内相邻且相等的元素.

  std::vector<int> numbers = {1, 2, 2, 3, 4};
  // 使用 std::adjacent_find
  auto stdResult = std::adjacent_find(numbers.begin(), numbers.end());
  if (stdResult != numbers.end()) {
    fmt::println(
        "std::adjacent_find: Adjacent equal elements {} found at index {}",
        *stdResult, std::distance(numbers.begin(), stdResult));
    // 预期输出: std::adjacent_find: Adjacent equal elements 2 found at index 1
  } else {
    fmt::println("std::adjacent_find: No adjacent equal elements found");
  }
  
  // 使用 std::ranges::adjacent_find
  auto rangesResult = std::ranges::adjacent_find(numbers);
  if (rangesResult != numbers.end()) {
    fmt::println(
        "std::ranges::adjacent_find: Adjacent equal elements {} found at index "
        "{}",
        *rangesResult, std::distance(numbers.begin(), rangesResult));
    // 预期输出: std::ranges::adjacent_find: Adjacent equal elements 2 found at
    // index 1
  } else {
    fmt::println(
        "std::ranges::adjacent_find: No adjacent equal elements found");
  }

计数

• count, ranges::count: 统计等于指定值的元素个数.

  constexpr std::array v = {1, 2, 3, 3, 4, 5};
  
  // count
  fmt::println("Count of 3: {}", std::count(v.begin(), v.end(), 3));
  // Count of 3: 2
  
  // ranges::count
  fmt::println("Count of 3 (ranges): {}", std::ranges::count(v, 3));
  // Count of 3 (ranges): 2
  

• count_if, ranges::count_if: 统计满足条件的元素个数.

  constexpr std::array v = {1, 2, 3, 3, 4, 5};
  // count_if
  fmt::println("Count of elements greater than 3: {}",
               std::count_if(v.begin(), v.end(), [](int n) { return n > 3; }));
  // Count of elements greater than 3: 2
  
  // ranges::count_if
  fmt::println("Count of elements greater than 3 (ranges): {}\n",
               std::ranges::count_if(v, [](int n) { return n > 3; }));
  // Count of elements greater than 3 (ranges): 2
  

比较

• mismatch, ranges::mismatch: 找到两个范围中第一个不匹配的元素.

  std::vector<int> first = {1, 2, 3, 4, 5};
  std::vector<int> second = {1, 2, 6, 4, 5};
  
  // 使用 std::mismatch
  auto stdMismatch = std::mismatch(first.begin(), first.end(), second.begin());
  if (stdMismatch.first != first.end()) {
    fmt::println("std::mismatch: First mismatch at index {}, values: {} and {}",
                 std::distance(first.begin(), stdMismatch.first),
                 *stdMismatch.first, *stdMismatch.second);
    // 预期输出: std::mismatch: First mismatch at index 2, values: 3 and 6
  } else {
    fmt::println("std::mismatch: No mismatch found");
  }
  
  // 使用 std::ranges::mismatch
  auto rangesMismatch = std::ranges::mismatch(first, second);
  if (rangesMismatch.in1 != first.end()) {
    fmt::println(
        "std::ranges::mismatch: First mismatch at index {}, values: {} and {}",
        std::distance(first.begin(), rangesMismatch.in1), *rangesMismatch.in1,
        *rangesMismatch.in2);
    // 预期输出: std::ranges::mismatch: First mismatch at index 2, values: 3 and
    // 6
  } else {
    fmt::println("std::ranges::mismatch: No mismatch found");
  }

• equal, ranges::equal: 比较两个范围是否相等.

  std::vector<int> first = {1, 2, 3};
  std::vector<int> second = {1, 2, 3};
  
  // 使用 std::equal
  bool stdEqual = std::equal(first.begin(), first.end(), second.begin());
  fmt::println("std::equal: {}", stdEqual);
  // 预期输出: std::equal: true
  
  std::vector<int> third = {1, 2, 4};
  stdEqual = std::equal(first.begin(), first.end(), third.begin());
  fmt::println("std::equal (different): {}", stdEqual);
  // 预期输出: std::equal (different): false
  
  // 使用 std::ranges::equal
  bool rangesEqual = std::ranges::equal(first, second);
  fmt::println("std::ranges::equal: {}", rangesEqual);
  // 预期输出: std::ranges::equal: true
  
  rangesEqual = std::ranges::equal(first, third);
  fmt::println("std::ranges::equal (different): {}", rangesEqual);
  // 预期输出: std::ranges::equal (different): false
  

• search, ranges::search: 在一个范围中查找另一个范围第一次出现的位置.

  std::vector<int> mainRange = {1, 2, 3, 4, 5, 1, 2, 3};
  std::vector<int> subRange = {1, 2, 3};
  
  // 使用 std::search
  auto stdSearch = std::search(mainRange.begin(), mainRange.end(),
                               subRange.begin(), subRange.end());
  if (stdSearch != mainRange.end()) {
    fmt::println("std::search: Sub - range found starting at index {}",
                 std::distance(mainRange.begin(), stdSearch));
    // 预期输出: std::search: Sub - range found starting at index 0
  } else {
    fmt::println("std::search: Sub - range not found");
  }
  
  // 使用 std::ranges::search
  auto rangesSearch = std::ranges::search(mainRange, subRange);
  if (rangesSearch.begin() != mainRange.end()) {
    fmt::println("std::ranges::search: Sub - range found starting at index {}",
                 std::distance(mainRange.begin(), rangesSearch.begin()));
    // 预期输出: std::ranges::search: Sub - range found starting at index 0
  } else {
    fmt::println("std::ranges::search: Sub - range not found");
  }

• search_n, ranges::search_n: 在一个范围中查找连续 n 个等于指定值的元素.

  std::vector<int> numbers = {1, 2, 2, 2, 3, 4};
  int value = 2;
  int count = 3;
  
  // 使用 std::search_n
  auto stdSearchN = std::search_n(numbers.begin(), numbers.end(), count, value);
  if (stdSearchN != numbers.end()) {
    fmt::println("std::search_n: Sequence of {} {}s found starting at index {}",
                 count, value, std::distance(numbers.begin(), stdSearchN));
    // 预期输出: std::search_n: Sequence of 3 2s found starting at index 1
  } else {
    fmt::println("std::search_n: Sequence not found");
  }
  
  // 使用 std::ranges::search_n
  auto rangesSearchN = std::ranges::search_n(numbers, count, value);
  if (rangesSearchN.begin() != numbers.end()) {
    fmt::println(
        "std::ranges::search_n: Sequence of {} {}s found starting at index {}",
        count, value, std::distance(numbers.begin(), rangesSearchN.begin()));
    // 预期输出: std::ranges::search_n: Sequence of 3 2s found starting at index
    // 1
  } else {
    fmt::println("std::ranges::search_n: Sequence not found");
  }

• ranges::starts_with: 检查一个范围是否以另一个范围开头.

  #ifdef _MSC_VER
  std::vector<int> mainRange = {1, 2, 3, 4, 5};
  std::vector<int> startRange = {1, 2, 3};
  
  bool startsWith = std::ranges::starts_with(mainRange, startRange);
  fmt::println("std::ranges::starts_with: {}", startsWith);
  // 预期输出: std::ranges::starts_with: true
  
  std::vector<int> wrongStartRange = {2, 3, 4};
  startsWith = std::ranges::starts_with(mainRange, wrongStartRange);
  fmt::println("std::ranges::starts_with (wrong): {}", startsWith);
  // 预期输出: std::ranges::starts_with (wrong): false
  #endif

• ranges::ends_with: 检查一个范围是否以另一个范围结尾.

  #ifdef _MSC_VER
  std::vector<int> mainRange = {1, 2, 3, 4, 5};
  std::vector<int> endRange = {3, 4, 5};
  
  bool endsWith = std::ranges::ends_with(mainRange, endRange);
  fmt::println("std::ranges::ends_with: {}", endsWith);
  // 预期输出: std::ranges::ends_with: true
  
  std::vector<int> wrongEndRange = {4, 5, 6};
  endsWith = std::ranges::ends_with(mainRange, wrongEndRange);
  fmt::println("std::ranges::ends_with (wrong): {}", endsWith);
  // 预期输出: std::ranges::ends_with (wrong): false
  #endif

Fold operations (C++23)

• ranges::fold_left(C++23): 从左到右折叠范围中的元素.
• ranges::fold_left_first(C++23): 从左到右折叠范围中的元素, 初始值为范围的第一个元素.
• ranges::fold_right(C++23): 从右到左折叠范围中的元素.
• ranges::fold_right_last(C++23): 从右到左折叠范围中的元素, 初始值为范围的最后一个元素.
• ranges::fold_left_with_iter(C++23): 从左到右折叠范围中的元素, 并返回迭代器.
• ranges::fold_left_first_with_iter(C++23): 从左到右折叠范围中的元素, 初始值为范围的第一个元素, 并返回迭代器.

修改序列

这些算法会修改容器或范围中的元素.

拷贝和移动

• copy, ranges::copy: 将一个范围的元素拷贝到另一个范围.

  std::vector source = {1, 2, 3, 4, 5};
  std::vector<int> destination(5);
  
  // 使用 std::copy
  std::copy(source.begin(), source.end(), destination.begin());
  fmt::println("std::copy: {}", destination);
  // 预期输出: std::copy: [1, 2, 3, 4, 5]
  
  source = {1, 2, 3, 4, 5};
  destination.resize(5);
  // 使用 std::ranges::copy
  std::ranges::copy(source, destination.begin());
  fmt::println("std::ranges::copy: {}", destination);
  // 预期输出: std::ranges::copy: [1, 2, 3, 4, 5]
  

• copy_if, ranges::copy_if: 拷贝满足条件的元素.

  std::vector source = {1, 2, 3, 4, 5};
  std::vector<int> destination;
  auto isEven = [](int num) { return num % 2 == 0; };
  
  // 使用 std::copy_if
  std::copy_if(source.begin(), source.end(), std::back_inserter(destination),
               isEven);
  fmt::println("std::copy_if: {}", destination);
  // 预期输出: std::copy_if: [2, 4]
  
  source = {1, 2, 3, 4, 5};
  destination.clear();
  // 使用 std::ranges::copy_if
  std::ranges::copy_if(source, std::back_inserter(destination), isEven);
  fmt::println("std::ranges::copy_if: {}", destination);
  // 预期输出: std::ranges::copy_if: [2, 4]
  

• copy_n, ranges::copy_n: 拷贝指定个数的元素.

  std::vector source = {1, 2, 3, 4, 5};
  std::vector<int> destination(3);
  
  // 使用 std::copy_n
  std::copy_n(source.begin(), 3, destination.begin());
  fmt::println("std::copy_n: {}", destination);
  // 预期输出: std::copy_n: [1, 2, 3]
  
  source = {1, 2, 3, 4, 5};
  destination.resize(3);
  // 使用 std::ranges::copy_n
  std::ranges::copy_n(source.begin(), 3, destination.begin());
  fmt::println("std::ranges::copy_n: {}", destination);
  // 预期输出: std::ranges::copy_n: [1, 2, 3]
  

• copy_backward, ranges::copy_backward: 从后往前拷贝元素.

  std::vector source = {1, 2, 3, 4, 5};
  std::vector<int> destination(5);
  
  // 使用 std::copy_backward
  std::copy_backward(source.begin(), source.end(), destination.end());
  fmt::println("std::copy_backward: {}", destination);
  // 预期输出: std::copy_backward: [1, 2, 3, 4, 5]
  
  source = {1, 2, 3, 4, 5};
  destination.resize(5);
  // 使用 std::ranges::copy_backward
  std::ranges::copy_backward(source, destination.end());
  fmt::println("std::ranges::copy_backward: {}", destination);
  // 预期输出: std::ranges::copy_backward: [1, 2, 3, 4, 5]
  

• move, ranges::move: 将元素从一个范围移动到另一个范围.

  std::vector<int> source = {1, 2, 3, 4, 5};
  std::vector<int> destination(5);
  
  // 使用 std::move
  std::move(source.begin(), source.end(), destination.begin());
  fmt::println("std::move: {}", destination);
  // 预期输出: std::move: [1, 2, 3, 4, 5]
  
  source = {1, 2, 3, 4, 5};
  destination.resize(5);
  // 使用 std::ranges::move
  std::ranges::move(source, destination.begin());
  fmt::println("std::ranges::move: {}", destination);
  // 预期输出: std::ranges::move: [1, 2, 3, 4, 5]
  

• move_backward, ranges::move_backward: 从后往前移动元素.

  std::vector<int> source = {1, 2, 3, 4, 5};
  std::vector<int> destination(5);
  
  // 使用 std::move_backward
  std::move_backward(source.begin(), source.end(), destination.end());
  fmt::println("std::move_backward: {}", destination);
  // 预期输出: std::move_backward: [1, 2, 3, 4, 5]
  
  source = {1, 2, 3, 4, 5};
  destination.resize(5);
  // 使用 std::ranges::move_backward
  std::ranges::move_backward(source, destination.end());
  fmt::println("std::ranges::move_backward: {}", destination);
  // 预期输出: std::ranges::move_backward: [1, 2, 3, 4, 5]
  

交换操作

• swap: 交换两个值.

  int a = 5, b = 10;
  std::swap(a, b);
  fmt::println("std::swap: a = {}, b = {}", a, b);
  // 预期输出: std::swap: a = 10, b = 5
  

• swap_ranges, ranges::swap_ranges: 交换两个范围的元素.

  std::vector first = {1, 2, 3};
  std::vector second = {4, 5, 6};
  // 使用 std::swap_ranges
  std::swap_ranges(first.begin(), first.end(), second.begin());
  fmt::println("std::swap_ranges: first = {}, second = {}", first, second);
  // 预期输出: std::swap_ranges: first = [4, 5, 6], second = [1, 2, 3]
  
  first = {1, 2, 3};
  second = {4, 5, 6};
  // 使用 std::ranges::swap_ranges
  std::ranges::swap_ranges(first, second);
  fmt::println("std::ranges::swap_ranges: first = {}, second = {}", first,
               second);
  // 预期输出: std::ranges::swap_ranges: first = [4, 5, 6], second = [1, 2, 3]
  

• iter_swap: 交换两个迭代器所指向的元素.

  std::vector numbers = {1, 2, 3, 4, 5};
  auto iter1 = numbers.begin();
  auto iter2 = numbers.begin() + 2;
  // 使用 std::iter_swap
  std::iter_swap(iter1, iter2);
  fmt::println("std::iter_swap: {}", numbers);
  // 预期输出: std::iter_swap: [3, 2, 1, 4, 5]
  

变换操作

变换

• transform, ranges::transform: 对范围内的每个元素应用函数, 并将结果存储到另一个范围.

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> result(numbers.size());

// 使用 transform 将每个元素乘以 2 并存储到 result 中
std::transform(numbers.begin(), numbers.end(), result.begin(),
                [](int num) { return num * 2; });

// 使用 ranges::transform 做同样的操作
std::vector<int> resultRanges(numbers.size());
std::ranges::transform(numbers, resultRanges.begin(),
                        [](int num) { return num * 2; });

// 输出 transform 的结果
fmt::print("transform 结果: {}\n", result);

// 输出 ranges::transform 的结果
fmt::print("ranges::transform 结果: {}\n", resultRanges);

替换

• replace, ranges::replace: 将范围内的指定值替换为新值.

  std::vector v = {1, 2, 3, 2, 4, 2};
  // 使用 std::replace
  std::replace(v.begin(), v.end(), 2, 9);
  fmt::println("std::replace: {}", v);
  // 预期输出: std::replace: [1, 9, 3, 9, 4, 9]
  
  v = {1, 2, 3, 2, 4, 2};
  // 使用 std::ranges::replace
  std::ranges::replace(v, 2, 9);
  fmt::println("std::ranges::replace: {}", v);
  // 预期输出: std::ranges::replace: [1, 9, 3, 9, 4, 9]
  

• replace_if, ranges::replace_if: 替换满足条件的元素.

  std::vector v = {1, 2, 3, 4, 5, 6};
  auto is_odd = [](int num) { return num % 2 == 0; };
  // 使用 std::replace_if
  std::replace_if(v.begin(), v.end(), is_odd, 0);
  fmt::println("std::replace_if: {}", v);
  // 预期输出: std::replace_if: [1, 0, 3, 0, 5, 0]
  
  v = {1, 2, 3, 4, 5, 6};
  // 使用 std::ranges::replace_if
  std::ranges::replace_if(v, is_odd, 0);
  fmt::println("std::ranges::replace_if: {}", v);
  // 预期输出: std::ranges::replace_if: [1, 0, 3, 0, 5, 0]
  

• replace_copy, ranges::replace_copy: 拷贝范围中的元素, 同时将指定值替换为新值.

  std::vector v = {1, 2, 3, 2, 4, 2};
  std::vector<int> result(v.size());
  // 使用 std::replace_copy
  std::replace_copy(v.begin(), v.end(), result.begin(), 2, 9);
  fmt::println("std::replace_copy: {}", result);
  // 预期输出: std::replace_copy: [1, 9, 3, 9, 4, 9]
  
  v = {1, 2, 3, 2, 4, 2};
  result.clear();
  result.resize(v.size());
  // 使用 std::ranges::replace_copy
  std::ranges::replace_copy(v, result.begin(), 2, 9);
  fmt::println("std::ranges::replace_copy: {}", result);
  // 预期输出: std::ranges::replace_copy: [1, 9, 3, 9, 4, 9]
  

• replace_copy_if, ranges::replace_copy_if: 拷贝范围中的元素, 同时将满足条件的元素替换为新值.

  std::vector<int> v = {1, 2, 3, 4, 5, 6};
  std::vector<int> result(v.size());
  // 使用 std::replace_copy_if
  std::replace_copy_if(
      v.begin(), v.end(), result.begin(), [](int num) { return num % 2 == 0; },
      0);
  fmt::println("std::replace_copy_if: {}", result);
  // 预期输出: std::replace_copy_if: [1, 0, 3, 0, 5, 0]
  
  v = {1, 2, 3, 4, 5, 6};
  result.clear();
  result.resize(v.size());
  // 使用 std::ranges::replace_copy_if
  std::ranges::replace_copy_if(
      v, result.begin(), [](int num) { return num % 2 == 0; }, 0);
  fmt::println("std::ranges::replace_copy_if: {}", result);
  // 预期输出: std::ranges::replace_copy_if: [1, 0, 3, 0, 5, 0]
  

生成操作

• fill, ranges::fill: 将范围内所有元素赋值为指定值.

  std::vector<int> v(6);
  // 使用 std::fill
  std::fill(v.begin(), v.end(), 9);
  fmt::println("std::fill: {}", v);
  // 预期输出: std::fill: [9, 9, 9, 9, 9, 9]
  
  v.resize(6);
  // 使用 std::ranges::fill
  std::ranges::fill(v, 9);
  fmt::println("std::ranges::fill: {}", v);
  // 预期输出: std::ranges::fill: [9, 9, 9, 9, 9, 9]
  

• fill_n, ranges::fill_n: 对指定个数的元素赋值.

  std::vector<int> v(6);
  // 使用 std::fill_n
  std::fill_n(v.begin(), 3, 5);
  fmt::println("std::fill_n: {}",
                v);  // 预期输出: std::fill_n: [5, 5, 5, 0, 0, 0]
  
  v.resize(6);
  // 使用 std::ranges::fill_n
  std::ranges::fill_n(v.begin(), 3, 5);
  fmt::println("std::ranges::fill_n: {}",
                v);  // 预期输出: std::ranges::fill_n: [5, 5, 5, 0, 0, 0]
  

• generate, ranges::generate: 使用函数生成范围内的值.

  std::vector<int> v(6);
  int counter = 1;
  auto generator = [&counter]() { return counter++; };
  // 使用 std::generate
  std::generate(v.begin(), v.end(), generator);
  fmt::println("std::generate: {}",
                v);  // 预期输出: std::generate: [1, 2, 3, 4, 5, 6]
  
  v.resize(6);
  counter = 1;
  // 使用 std::ranges::generate
  std::ranges::generate(v, generator);
  fmt::println("std::ranges::generate: {}",
                v);  // 预期输出: std::ranges::generate: [1, 2, 3, 4, 5, 6]
  

• generate_n, ranges::generate_n: 为前 N 个元素生成值.

  std::vector<int> v(6);
  int counter = 1;
  auto generator = [&counter]() { return counter++; };
  // 使用 std::generate_n
  std::generate_n(v.begin(), 3, generator);
  fmt::println("std::generate_n: {}",
                v);  // 预期输出: std::generate_n: [1, 2, 3, 0, 0, 0]
  
  v.resize(6);
  counter = 1;
  // 使用 std::ranges::generate_n
  std::ranges::generate_n(v.begin(), 3, generator);
  fmt::println("std::ranges::generate_n: {}",
                v);  // 预期输出: std::ranges::generate_n: [1, 2, 3, 0, 0, 0]
  

移除操作

• remove, ranges::remove: 移除指定值的元素(逻辑移除, 不改变容器大小).

  std::vector<int> src = {1, 2, 3, 2, 4, 2};
  // 使用 std::remove
  auto newEnd = std::remove(src.begin(), src.end(), 2);
  fmt::println("std::remove: {}", std::vector<int>(src.begin(), newEnd));
  // 预期输出: std::remove: [1, 3, 4]
  
  src = {1, 2, 3, 2, 4, 2};
  // 使用 std::ranges::remove
  auto result = std::ranges::remove(src, 2);
  src.erase(result.begin(), result.end());
  fmt::println("std::ranges::remove: {}", src);
  // 预期输出: std::ranges::remove: [1, 3, 4]
  

• remove_if, ranges::remove_if: 移除满足条件的元素(逻辑移除, 不改变容器大小).

  std::vector<int> src = {1, 2, 3, 4, 5, 6};
  // 使用 std::remove_if
  auto newEnd = std::remove_if(src.begin(), src.end(),
                                [](int num) { return num % 2 == 0; });
  fmt::println("std::remove_if: {}", std::vector<int>(src.begin(), newEnd));
  // 预期输出: std::remove_if: [1, 3, 5]
  
  src = {1, 2, 3, 4, 5, 6};
  // 使用 std::ranges::remove_if
  auto result =
      std::ranges::remove_if(src, [](int num) { return num % 2 == 0; });
  src.erase(result.begin(), result.end());
  fmt::println("std::ranges::remove_if: {}", src);
  // 预期输出: std::ranges::remove_if: [1, 3, 5]
  

• remove_copy, ranges::remove_copy: 拷贝范围中的元素, 同时移除指定值的元素.

  std::vector<int> src = {1, 2, 3, 2, 4, 2};
  std::vector<int> result;
  // 使用 std::remove_copy
  std::remove_copy(src.begin(), src.end(), std::back_inserter(result), 2);
  fmt::println("std::remove_copy: {}", result);
  // 预期输出: std::remove_copy: [1, 3, 4]
  
  src = {1, 2, 3, 2, 4, 2};
  result.clear();
  // 使用 std::ranges::remove_copy
  std::ranges::remove_copy(src, std::back_inserter(result), 2);
  fmt::println("std::ranges::remove_copy: {}", result);
  // 预期输出: std::ranges::remove_copy: [1, 3, 4]
  

• remove_copy_if, ranges::remove_copy_if: 拷贝范围中的元素, 同时移除满足条件的元素.

  std::vector<int> src = {1, 2, 3, 4, 5, 6};
  std::vector<int> result;
  // 使用 std::remove_copy_if
  std::remove_copy_if(src.begin(), src.end(), std::back_inserter(result),
                      [](int num) { return num % 2 == 0; });
  fmt::println("std::remove_copy_if: {}", result);
  // 预期输出: std::remove_copy_if: [1, 3, 5]
  
  src = {1, 2, 3, 4, 5, 6};
  result.clear();
  // 使用 std::ranges::remove_copy_if
  std::ranges::remove_copy_if(src, std::back_inserter(result),
                              [](int num) { return num % 2 == 0; });
  fmt::println("std::ranges::remove_copy_if: {}", result);
  // 预期输出: std::ranges::remove_copy_if: [1, 3, 5]
  

• unique, ranges::unique: 移除相邻的重复元素(逻辑移除, 不改变容器大小).

  std::vector<int> src = {1, 1, 2, 2, 3, 3};
  // 使用 std::unique
  auto newEnd = std::unique(src.begin(), src.end());
  fmt::println("std::unique: {}", std::vector<int>(src.begin(), newEnd));
  // 预期输出: std::unique: [1, 2, 3]
  
  src = {1, 1, 2, 2, 3, 3};
  // 使用 std::ranges::unique
  auto result = std::ranges::unique(src);
  src.erase(result.begin(), result.end());
  fmt::println("std::ranges::unique: {}", src);
  // 预期输出: std::ranges::unique: [1, 2, 3]
  

• unique_copy, ranges::unique_copy: 拷贝范围中的元素, 同时移除相邻的重复元素.

  std::vector<int> src = {1, 1, 2, 2, 3, 3};
  std::vector<int> result;
  // 使用 std::unique_copy
  std::unique_copy(src.begin(), src.end(), std::back_inserter(result));
  fmt::println("std::unique_copy: {}", result);
  // 预期输出: std::unique_copy: [1, 2, 3]
  
  src = {1, 1, 2, 2, 3, 3};
  result.clear();
  // 使用 std::ranges::unique_copy
  std::ranges::unique_copy(src, std::back_inserter(result));
  fmt::println("std::ranges::unique_copy: {}", result);
  // 预期输出: std::ranges::unique_copy: [1, 2, 3]
  

改变顺序的操作

• reverse, ranges::reverse: 反转范围内的元素顺序.

  std::vector vec = {1, 2, 3, 4, 5};
  fmt::println("Original vector for reverse: {}", vec);
  // 预期输出: Original vector for reverse: [1, 2, 3, 4, 5]
  std::reverse(vec.begin(), vec.end());
  fmt::println("After std::reverse: {}", vec);
  // 预期输出: After std::reverse: [5, 4, 3, 2, 1]
  

• reverse_copy, ranges::reverse_copy: 反转范围内的元素顺序并拷贝到另一个范围.

  std::vector vec = {1, 2, 3, 4, 5};
  std::vector<int> result(vec.size());
  fmt::println("Original vector for reverse_copy: {}", vec);
  // 预期输出: Original vector for reverse_copy: [1, 2, 3, 4, 5]
  std::reverse_copy(vec.begin(), vec.end(), result.begin());
  fmt::println("After std::reverse_copy: {}", result);
  // 预期输出: After std::reverse_copy: [5, 4, 3, 2, 1]
  

• rotate, ranges::rotate: 旋转范围内的元素.

  std::vector vec = {1, 2, 3, 4, 5};
  fmt::println("Original vector for rotate: {}", vec);
  // 预期输出: Original vector for rotate: [1, 2, 3, 4, 5]
  std::rotate(vec.begin(), vec.begin() + 2, vec.end());
  fmt::println("After std::rotate (rotate by 2): {}", vec);
  // 预期输出: After std::rotate (rotate by 2): [3, 4, 5, 1, 2]
  

• rotate_copy, ranges::rotate_copy: 旋转范围内的元素并拷贝到另一个范围.

  std::vector vec = {1, 2, 3, 4, 5};
  std::vector<int> result(vec.size());
  fmt::println("Original vector for rotate_copy: {}", vec);
  // 预期输出: Original vector for rotate_copy: [1, 2, 3, 4, 5]
  std::rotate_copy(vec.begin(), vec.begin() + 2, vec.end(), result.begin());
  fmt::println("After std::rotate_copy (rotate by 2): {}", result);
  // 预期输出: After std::rotate_copy (rotate by 2): [3, 4, 5, 1, 2]
  

• shift_left, ranges::shift_left: 向左移动范围内的元素.

  std::vector<int> vec = {1, 2, 3, 4, 5};
  fmt::println("Original vector for shift_left: {}", vec);
  // 预期输出: Original vector for shift_left: [1, 2, 3, 4, 5]
  auto new_end = std::shift_left(vec.begin(), vec.end(), 2);
  vec.erase(new_end, vec.end());
  vec.resize(5);
  fmt::println("After std::shift_left (shift by 2): {}", vec);
  // 预期输出: After std::shift_left (shift by 2): [3, 4, 5, 0, 0]
  

  #ifdef _MSC_VER
  std::vector<int> vec = {1, 2, 3, 4, 5};
  fmt::println("Original vector for ranges::shift_left: {}", vec);
  // 预期输出: Original vector for ranges::shift_left: [1, 2, 3, 4, 5]
  auto r_new_end = std::ranges::shift_left(vec, 2);
  vec.erase(r_new_end.begin(), r_new_end.end());
  vec.resize(5);
  fmt::println("After std::ranges::shift_left (shift by 2): {}", vec);
  // 预期输出: After std::ranges::shift_left (shift by 2): [3, 4, 5, 0, 0]
  #endif

• shift_right, ranges::shift_right: 向右移动范围内的元素.

  std::vector<int> vec = {1, 2, 3, 4, 5};
  fmt::println("Original vector for shift_right: {}", vec);
  // 预期输出: Original vector for shift_right: [1, 2, 3, 4, 5]
  auto new_end = std::shift_right(vec.begin(), vec.end(), 2);
  vec.erase(new_end, vec.end());
  vec.resize(5);
  fmt::println("After std::shift_right (shift by 2): {}", vec);
  // 预期输出: After std::shift_right (shift by 2): [0, 0, 1, 2, 3]
  

  #ifdef _MSC_VER
  std::vector<int> vec = {1, 2, 3, 4, 5};
  fmt::println("Original vector for ranges::shift_right: {}", vec);
  // 预期输出: Original vector for ranges::shift_right: [1, 2, 3, 4, 5]
  auto r_new_end = std::ranges::shift_right(vec, 2);
  vec.erase(r_new_end.begin(), r_new_end.end());
  vec.resize(5);
  fmt::println("After std::ranges::shift_right (shift by 2): {}", vec);
  // 预期输出: After std::ranges::shift_right (shift by 2): [0, 0, 1, 2, 3]
  #endif

• shuffle, ranges::shuffle: 随机打乱范围内的元素.

• random_shuffle: 随机打乱范围内的元素(C++17 删除该特性).

// shuffle
void shuffleExample() {
  std::vector<int> vec = {1, 2, 3, 4, 5};
  std::random_device rd;
  std::mt19937 g(rd());
  fmt::println("Original vector for shuffle: {}", vec);
  // 预期输出: Original vector for shuffle: [1, 2, 3, 4, 5]
  std::shuffle(vec.begin(), vec.end(), g);
  fmt::println("After std::shuffle: {}", vec);  // 预期输出: 随机打乱后的向量
}

// ranges::shuffle
void rangesShuffleExample() {
  std::vector<int> vec = {1, 2, 3, 4, 5};
  std::random_device rd;
  std::mt19937 g(rd());
  fmt::println("Original vector for ranges::shuffle: {}", vec);
  // 预期输出: Original vector for ranges::shuffle: [1, 2, 3, 4, 5]
  std::ranges::shuffle(vec, g);
  fmt::println("After std::ranges::shuffle: {}",
               vec);  // 预期输出: 随机打乱后的向量
}

抽样操作

• sample, ranges::sample: 从范围中随机抽样.

  constexpr std::array v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  std::vector<int> result(3);  // 抽样结果存储的容器
  
  // 创建随机数引擎
  std::random_device rd;
  std::mt19937 gen(rd());
  
  // 使用 std::sample
  std::sample(v.begin(), v.end(), result.begin(), 3, gen);
  fmt::println("std::sample: {}", result);
  
  // 使用 std::ranges::sample
  std::ranges::sample(v, result.begin(), 3, gen);
  fmt::println("std::ranges::sample: {}", result);

partition 操作

• is_partitioned, ranges::is_partitioned: 检查范围是否已被分区.

  std::vector v = {1, 3, 5, 2, 4, 6};
  auto is_even = [](int num) { return num % 2 == 0; };
  // 使用 std::is_partitioned
  bool stdIsPartitioned = std::is_partitioned(v.begin(), v.end(), is_even);
  fmt::println("std::is_partitioned: {}", stdIsPartitioned);
  // 预期输出: std::is_partitioned: false
  
  v = {2, 4, 6, 1, 3, 5};
  // 使用 std::ranges::is_partitioned
  bool rangesIsPartitioned = std::ranges::is_partitioned(v, is_even);
  fmt::println("std::ranges::is_partitioned: {}", rangesIsPartitioned);
  // 预期输出: std::ranges::is_partitioned: true
  

• partition, ranges::partition: 将范围中的元素按照条件分区.

  std::vector v = {1, 2, 3, 4, 5, 6};
  auto is_even = [](int num) { return num % 2 == 0; };
  // 使用 std::partition
  auto stdPartitionEnd = std::partition(v.begin(), v.end(), is_even);
  fmt::println("std::partition: {}",
               std::vector<int>(v.begin(), stdPartitionEnd));
  // 预期输出: 满足条件的元素组成的向量(顺序可能不同)
  fmt::println("std::partition rest: {}",
               std::vector<int>(stdPartitionEnd, v.end()));
  // 预期输出: 不满足条件的元素组成的向量(顺序可能不同)
  
  v = {1, 2, 3, 4, 5, 6};
  // 使用 std::ranges::partition
  auto result = std::ranges::partition(v, is_even);
  fmt::println("std::ranges::partition: {}",
               std::vector<int>(v.begin(), result.begin()));
  // 预期输出: 满足条件的元素组成的向量(顺序可能不同)
  fmt::println("std::ranges::partition rest: {}",
               std::vector<int>(result.begin(), v.end()));
  // 预期输出: 不满足条件的元素组成的向量(顺序可能不同)
  

• partition_copy, ranges::partition_copy: 将范围中的元素按照条件分区并拷贝到两个不同的范围.

  std::vector<int> v = {1, 2, 3, 4, 5, 6};
  std::vector<int> trueResult, falseResult;
  auto is_even = [](int num) { return num % 2 == 0; };
  // 使用 std::partition_copy
  std::partition_copy(v.begin(), v.end(), std::back_inserter(trueResult),
                      std::back_inserter(falseResult), is_even);
  fmt::println("std::partition_copy true: {}", trueResult);
  // 预期输出: 满足条件的元素组成的向量
  fmt::println("std::partition_copy false: {}", falseResult);
  // 预期输出: 不满足条件的元素组成的向量
  
  v = {1, 2, 3, 4, 5, 6};
  trueResult.clear();
  falseResult.clear();
  // 使用 std::ranges::partition_copy
  std::ranges::partition_copy(v, std::back_inserter(trueResult),
                              std::back_inserter(falseResult), is_even);
  fmt::println("std::ranges::partition_copy true: {}", trueResult);
  // 预期输出: 满足条件的元素组成的向量
  fmt::println("std::ranges::partition_copy false: {}", falseResult);
  // 预期输出: 不满足条件的元素组成的向量
  

• stable_partition, ranges::stable_partition: 将范围中的元素按照条件分区, 同时保持相对顺序.

  std::vector v = {1, 2, 3, 4, 5, 6};
  auto is_even = [](int num) { return num % 2 == 0; };
  // 使用 std::stable_partition
  auto stdStablePartitionEnd =
      std::stable_partition(v.begin(), v.end(), is_even);
  fmt::println("std::stable_partition: {}",
               std::vector<int>(v.begin(), stdStablePartitionEnd));
  // 预期输出: 满足条件的元素组成的向量(保持相对顺序)
  fmt::println("std::stable_partition rest: {}",
               std::vector<int>(stdStablePartitionEnd, v.end()));
  // 预期输出: 不满足条件的元素组成的向量(保持相对顺序)
  
  v = {1, 2, 3, 4, 5, 6};
  // 使用 std::ranges::stable_partition
  auto rangesStablePartitionResult = std::ranges::stable_partition(v, is_even);
  fmt::println(
      "std::ranges::stable_partition: {}",
      std::vector<int>(v.begin(), rangesStablePartitionResult.begin()));
  // 预期输出: 满足条件的元素组成的向量(保持相对顺序)
  fmt::println("std::ranges::stable_partition rest: {}",
               std::vector<int>(rangesStablePartitionResult.begin(), v.end()));
  // 预期输出: 不满足条件的元素组成的向量(保持相对顺序)
  

• partition_point, ranges::partition_point: 查找分区点.

  std::vector v = {2, 4, 6, 1, 3, 5};
  auto is_even = [](int num) { return num % 2 == 0; };
  // 使用 std::partition_point
  auto stdPartitionPoint = std::partition_point(v.begin(), v.end(), is_even);
  fmt::println("std::partition_point: {}", *stdPartitionPoint);
  // 预期输出: 分区点的元素值, 这里是 1
  
  v = {2, 4, 6, 1, 3, 5};
  // 使用 std::ranges::partition_point
  auto rangesPartitionPoint = std::ranges::partition_point(v, is_even);
  fmt::println("std::ranges::partition_point: {}", *rangesPartitionPoint);
  // 预期输出: 分区点的元素值, 这里是 1