当前位置：首页 > news >正文

一文总结C++ STL算法库

news 2025/2/11 18:02:56

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: truestd::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: truerangesEqual = 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: truestd::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: truestd::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: falsev = {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);
// 预期输出: 分区点的元素值，这里是 1v = {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

排序相关算法

排序算法对范围中的元素重新排列.

sort, ranges::sort: 对范围内的元素进行升序排序.

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

stable_sort, ranges::stable_sort: 稳定排序, 保持相等元素的顺序.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::stable_sort
std::stable_sort(numbers.begin(), numbers.end());
fmt::println("std::stable_sort: {}", numbers);
// 预期输出: 元素升序排列且相等元素相对顺序不变的向量，例如 [1, 1, 2, 3, 3, 4,
// 5, 5, 5, 6, 9]numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::ranges::stable_sort
std::ranges::stable_sort(numbers);
fmt::println("std::ranges::stable_sort: {}", numbers);
// 预期输出: 元素升序排列且相等元素相对顺序不变的向量，例如 [1, 1, 2, 3, 3, 4,
// 5, 5, 5, 6, 9]

partial_sort, ranges::partial_sort: 对范围的前几个元素进行排序.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::partial_sort 对前 5 个元素排序
std::partial_sort(numbers.begin(), numbers.begin() + 5, numbers.end());
fmt::println("std::partial_sort: {}", numbers);
// 预期输出: 前 5 个元素升序排列，后面元素无序，例如 [1, 1, 2, 3, 3, 9, 5, 6,
// 5, 4, 5]numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::ranges::partial_sort 对前 5 个元素排序
std::ranges::partial_sort(numbers.begin(), numbers.begin() + 5,numbers.end());
fmt::println("std::ranges::partial_sort: {}", numbers);
// 预期输出: 前 5 个元素升序排列，后面元素无序，例如 [1, 1, 2, 3, 3, 9, 5, 6,
// 5, 4, 5]

partial_sort_copy, ranges::partial_sort_copy: 部分排序并拷贝.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
std::vector<int> result(5);
// 使用 std::partial_sort_copy
std::partial_sort_copy(numbers.begin(), numbers.end(), result.begin(),result.end());
fmt::println("std::partial_sort_copy: {}", result);
// 预期输出: 原向量中最小的 5 个元素升序排列的向量，例如 [1, 1, 2, 3, 3]numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
result.clear();
result.resize(5);
// 使用 std::ranges::partial_sort_copy
std::ranges::partial_sort_copy(numbers, result);
fmt::println("std::ranges::partial_sort_copy: {}", result);
// 预期输出: 原向量中最小的 5 个元素升序排列的向量，例如 [1, 1, 2, 3, 3]

is_sorted, ranges::is_sorted: 检查范围是否已排序.

std::vector<int> numbers = {1, 2, 3, 4, 5};
// 使用 std::is_sorted
bool stdIsSorted = std::is_sorted(numbers.begin(), numbers.end());
fmt::println("std::is_sorted: {}", stdIsSorted);
// 预期输出: std::is_sorted: truenumbers = {3, 1, 4};
// 使用 std::ranges::is_sorted
bool rangesIsSorted = std::ranges::is_sorted(numbers);
fmt::println("std::ranges::is_sorted: {}", rangesIsSorted);
// 预期输出: std::ranges::is_sorted: false

is_sorted_until, ranges::is_sorted_until: 查找范围中第一个未排序的元素.

std::vector<int> numbers = {1, 2, 3, 1, 4};
// 使用 std::is_sorted_until
auto stdSortedUntil = std::is_sorted_until(numbers.begin(), numbers.end());
fmt::println("std::is_sorted_until: {}", *stdSortedUntil);
// 预期输出: std::is_sorted_until: 1numbers = {1, 2, 3, 1, 4};
// 使用 std::ranges::is_sorted_until
auto rangesSortedUntil = std::ranges::is_sorted_until(numbers);
fmt::println("std::ranges::is_sorted_until: {}", *rangesSortedUntil);
// 预期输出: std::ranges::is_sorted_until: 1

nth_element, ranges::nth_element: 将指定位置的元素调整到排序后的位置.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::nth_element 找到第 5 小的元素（索引为 4）
std::nth_element(numbers.begin(), numbers.begin() + 4, numbers.end());
fmt::println("std::nth_element: {}", numbers[4]);
// 预期输出: 第 5 小的元素，例如 3numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::ranges::nth_element 找到第 5 小的元素（索引为 4）
std::ranges::nth_element(numbers, numbers.begin() + 4);
fmt::println("std::ranges::nth_element: {}", numbers[4]);
// 预期输出: 第 5 小的元素，例如 3

二分查找

lower_bound, ranges::lower_bound: 找到第一个不小于指定值的位置.

constexpr std::array vec = {1, 2, 4, 4, 5, 6, 7};
constexpr int target = 4;
// 使用 std::lower_bound
fmt::println("std::lower_bound: {}",std::lower_bound(vec.begin(), vec.end(), target) - vec.begin());
// 预期输出: std::lower_bound: 2// 使用 std::ranges::lower_bound
fmt::println("std::ranges::lower_bound: {}",std::ranges::lower_bound(vec, target) - vec.begin());
// 预期输出: std::ranges::lower_bound: 2

upper_bound, ranges::upper_bound: 找到第一个大于指定值的位置.

constexpr std::array vec = {1, 2, 4, 4, 5, 6, 7};
constexpr int target = 4;
// 使用 std::upper_bound
fmt::println("std::upper_bound: {}",std::upper_bound(vec.begin(), vec.end(), target) - vec.begin());
// 预期输出: std::upper_bound: 4// 使用 std::ranges::upper_bound
fmt::println("std::ranges::upper_bound: {}",std::ranges::upper_bound(vec, target) - vec.begin());
// 预期输出: std::ranges::upper_bound: 4

equal_range, ranges::equal_range: 找到等于指定值的范围.

constexpr std::array vec = {1, 2, 4, 4, 5, 6, 7};
constexpr int target = 4;
// 使用 std::equal_range
auto stdEqualRange = std::equal_range(vec.begin(), vec.end(), target);
fmt::println("std::equal_range: [{}, {}]", stdEqualRange.first - vec.begin(),stdEqualRange.second - vec.begin());
// 预期输出: std::equal_range: [2, 4]// 使用 std::ranges::equal_range
auto rangesEqualRange = std::ranges::equal_range(vec, target);
fmt::println("std::ranges::equal_range: [{}, {}]",rangesEqualRange.begin() - vec.begin(),rangesEqualRange.end() - vec.begin());
// 预期输出: std::ranges::equal_range: [2, 4]

binary_search, ranges::binary_search: 检查范围内是否包含指定值(范围必须有序).

constexpr std::array vec = {1, 2, 4, 4, 5, 6, 7};
constexpr int target1 = 4;
constexpr int target2 = 3;
// 使用 std::binary_search
fmt::println("std::binary_search for {}: {}", target1,std::binary_search(vec.begin(), vec.end(), target1));
// 预期输出: std::binary_search for 4: true
fmt::println("std::binary_search for {}: {}", target2,std::binary_search(vec.begin(), vec.end(), target2));
// 预期输出: std::binary_search for 3: false// 使用 std::ranges::binary_search
fmt::println("std::ranges::binary_search for {}: {}", target1,std::ranges::binary_search(vec, target1));
// 预期输出: std::ranges::binary_search for 4: true
fmt::println("std::ranges::binary_search for {}: {}", target2,std::ranges::binary_search(vec, target2));
// 预期输出: std::ranges::binary_search for 3: false

集合操作

includes, ranges::includes: 检查一个范围是否包含另一个范围.

constexpr std::array larger = {1, 2, 3, 4, 5, 6};
constexpr std::array smaller = {2, 4, 6};
// 使用 std::includes
fmt::println("std::includes: {}",std::includes(larger.begin(), larger.end(), smaller.begin(),smaller.end()));
// 预期输出: std::includes: true// 使用 std::ranges::includes
fmt::println("std::ranges::includes: {}",std::ranges::includes(larger, smaller));
// 预期输出: std::ranges::includes: true

set_union, ranges::set_union: 计算两个有序范围的并集.

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

set_intersection, ranges::set_intersection: 计算两个有序范围的交集.

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

set_difference, ranges::set_difference: 计算两个有序范围的差集.

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

set_symmetric_difference, ranges::set_symmetric_difference: 计算两个有序范围的对称差集.

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

Merge operations

merge, ranges::merge: 合并两个有序范围.

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

inplace_merge, ranges::inplace_merge: 原地合并两个有序范围.

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

堆操作

push_heap, ranges::push_heap: 将新元素插入堆.

std::vector<int> heap = {3, 1, 2};
// 先将范围转换为堆
std::make_heap(heap.begin(), heap.end());
// 插入新元素
heap.push_back(4);
// 使用 std::push_heap
std::push_heap(heap.begin(), heap.end());
fmt::println("std::push_heap: {}", heap);
// 预期输出: std::push_heap: [4, 3, 2, 1]heap = {3, 1, 2};
std::ranges::make_heap(heap);
heap.push_back(4);
// 使用 std::ranges::push_heap
std::ranges::push_heap(heap);
fmt::println("std::ranges::push_heap: {}", heap);
// 预期输出: std::ranges::push_heap: [4, 3, 2, 1]

pop_heap, ranges::pop_heap: 从堆中移除最大元素.

std::vector<int> heap = {4, 3, 2, 1};
// 使用 std::pop_heap
std::pop_heap(heap.begin(), heap.end());
int popped = heap.back();
heap.pop_back();
fmt::println("std::pop_heap popped: {}, remaining: {}", popped, heap);
// 预期输出: std::pop_heap popped: 4, remaining: [3, 1, 2]heap = {4, 3, 2, 1};
// 使用 std::ranges::pop_heap
std::ranges::pop_heap(heap);
popped = heap.back();
heap.pop_back();
fmt::println("std::ranges::pop_heap popped: {}, remaining: {}", popped, heap);
// 预期输出: std::ranges::pop_heap popped: 4, remaining: [3, 1, 2]

make_heap, ranges::make_heap: 将范围转换为堆.

std::vector<int> numbers = {3, 1, 2};
// 使用 std::make_heap
std::make_heap(numbers.begin(), numbers.end());
fmt::println("std::make_heap: {}", numbers);
// 预期输出: std::make_heap: [3, 1, 2]（可能形式，堆结构不唯一）numbers = {3, 1, 2};
// 使用 std::ranges::make_heap
std::ranges::make_heap(numbers);
fmt::println("std::ranges::make_heap: {}", numbers);
// 预期输出: std::ranges::make_heap: [3, 1, 2]（可能形式，堆结构不唯一）

sort_heap, ranges::sort_heap: 对堆排序.

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

is_heap, ranges::is_heap: 检查范围是否为堆.

std::vector<int> heap = {4, 3, 2, 1};
// 使用 std::is_heap
bool stdIsHeap = std::is_heap(heap.begin(), heap.end());
fmt::println("std::is_heap: {}", stdIsHeap);
// 预期输出: std::is_heap: truestd::vector<int> notHeap = {1, 3, 2, 4};
stdIsHeap = std::is_heap(notHeap.begin(), notHeap.end());
fmt::println("std::is_heap (not heap): {}", stdIsHeap);
// 预期输出: std::is_heap (not heap): falseheap = {4, 3, 2, 1};
// 使用 std::ranges::is_heap
bool rangesIsHeap = std::ranges::is_heap(heap);
fmt::println("std::ranges::is_heap: {}", rangesIsHeap);
// 预期输出: std::ranges::is_heap: truenotHeap = {1, 3, 2, 4};
rangesIsHeap = std::ranges::is_heap(notHeap);
fmt::println("std::ranges::is_heap (not heap): {}", rangesIsHeap);
// 预期输出: std::ranges::is_heap (not heap): false

is_heap_until, ranges::is_heap_until: 查找范围中第一个不满足堆性质的元素.

std::vector<int> partialHeap = {4, 3, 1, 2, 5};
// 使用 std::is_heap_until
auto stdHeapUntil =std::is_heap_until(partialHeap.begin(), partialHeap.end());
fmt::println("std::is_heap_until: {}",std::distance(partialHeap.begin(), stdHeapUntil));
// 预期输出: std::is_heap_until: 3partialHeap = {4, 3, 1, 2, 5};
// 使用 std::ranges::is_heap_until
auto rangesHeapUntil = std::ranges::is_heap_until(partialHeap);
fmt::println("std::ranges::is_heap_until: {}",std::distance(partialHeap.begin(), rangesHeapUntil));
// 预期输出: std::ranges::is_heap_until: 3

最大最小值

max, ranges::max: 返回两个值中的最大值.

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

max_element, ranges::max_element: 查找范围内的最大元素.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::max_element
fmt::println("std::max_element: {}",*std::max_element(numbers.begin(), numbers.end()));
// 预期输出: std::max_element: 9// 使用 std::ranges::max_element
fmt::println("std::ranges::max_element: {}",*std::ranges::max_element(numbers));
// 预期输出: std::ranges::max_element: 9

min, ranges::min: 返回两个值中的最小值.

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

min_element, ranges::min_element: 查找范围内的最小元素.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::min_element
fmt::println("std::min_element: {}",*std::min_element(numbers.begin(), numbers.end()));
// 预期输出: std::min_element: 1// 使用 std::ranges::min_element
fmt::println("std::ranges::min_element: {}",*std::ranges::min_element(numbers));
// 预期输出: std::ranges::min_element: 1

minmax, ranges::minmax: 返回两个值中的最小值和最大值.

int a = 5, b = 10;
// 使用 std::minmax
auto stdMinMax = std::minmax(a, b);
fmt::println("std::minmax: min = {}, max = {}", stdMinMax.first,stdMinMax.second);
// 预期输出: std::minmax: min = 5, max = 10// 使用 std::ranges::minmax
auto rangesMinMax = std::ranges::minmax(a, b);
fmt::println("std::ranges::minmax: min = {}, max = {}", rangesMinMax.min,rangesMinMax.max);
// 预期输出: std::ranges::minmax: min = 5, max = 10

minmax_element, ranges::minmax_element: 查找范围内的最小元素和最大元素.

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
// 使用 std::minmax_element
auto stdMinMaxElement = std::minmax_element(numbers.begin(), numbers.end());
fmt::println("std::minmax_element: min = {}, max = {}",*stdMinMaxElement.first, *stdMinMaxElement.second);
// 预期输出: std::minmax_element: min = 1, max = 9// 使用 std::ranges::minmax_element
auto rangesMinMaxElement = std::ranges::minmax_element(numbers);
fmt::println("std::ranges::minmax_element: min = {}, max = {}",*rangesMinMaxElement.min, *rangesMinMaxElement.max);
// 预期输出: std::ranges::minmax_element: min = 1, max = 9

clamp, ranges::clamp: 将值限制在指定范围内.

int value = 15;
int low = 10, high = 20;
// 使用 std::clamp
fmt::println("std::clamp: {}", std::clamp(value, low, high));
// 预期输出: std::clamp: 15// 使用 std::ranges::clamp
fmt::println("std::ranges::clamp: {}", std::ranges::clamp(value, low, high));
// 预期输出: std::ranges::clamp: 15

Lexicographical comparison operations

lexicographical_compare, ranges::lexicographical_compare: 按字典序比较两个范围.

std::vector<int> first = {1, 2, 3};
std::vector<int> second = {1, 2, 4};// 使用 std::lexicographical_compare
bool stdResult = std::lexicographical_compare(first.begin(), first.end(),second.begin(), second.end());
fmt::println("std::lexicographical_compare: {}", stdResult);
// 预期输出: std::lexicographical_compare: true// 使用 std::ranges::lexicographical_compare
bool rangesResult = std::ranges::lexicographical_compare(first, second);
fmt::println("std::ranges::lexicographical_compare: {}", rangesResult);
// 预期输出: std::ranges::lexicographical_compare: true

lexicographical_compare_three_way: 按字典序比较两个范围(三路比较).

std::vector<int> first = {1, 2, 3};
std::vector<int> second = {1, 2, 4};// 使用 std::lexicographical_compare_three_way
auto stdThreeWayResult = std::lexicographical_compare_three_way(first.begin(), first.end(), second.begin(), second.end());
fmt::println("std::lexicographical_compare_three_way: {}",stdThreeWayResult < 0);
// 预期输出: std::lexicographical_compare_three_way: true// 可以根据三路比较结果进行不同判断
if (stdThreeWayResult < 0) {fmt::println("first is less than second");
} else if (stdThreeWayResult > 0) {fmt::println("first is greater than second");
} else {fmt::println("first is equal to second");
}

排列

next_permutation, ranges::next_permutation: 生成下一个字典序排列.

std::vector<int> numbers = {1, 2, 3};
// 使用 std::next_permutation
bool stdHasNext = std::next_permutation(numbers.begin(), numbers.end());
fmt::println("std::next_permutation: has next = {}, permutation = {}",stdHasNext, numbers);
fmt::println("std::next_permutation: permutation = {}", numbers);
// 预期输出: std::next_permutation: has next = true, permutation = [1, 3, 2]numbers = {1, 2, 3};
// 使用 std::ranges::next_permutation
auto rangesResult = std::ranges::next_permutation(numbers);
fmt::println("std::ranges::next_permutation: has next = {}, permutation ={}",rangesResult.found, numbers);
// 预期输出: std::ranges::next_permutation: has next = true, permutation = [1,
// 3, 2]

prev_permutation, ranges::prev_permutation: 生成上一个字典序排列.

std::vector<int> numbers = {3, 2, 1};
// 使用 std::prev_permutation
bool stdHasPrev = std::prev_permutation(numbers.begin(), numbers.end());
fmt::println("std::prev_permutation: has prev = {}, permutation = {}",stdHasPrev, numbers);
// 预期输出: std::prev_permutation: has prev = true, permutation = [3, 1, 2]numbers = {3, 2, 1};
// 使用 std::ranges::prev_permutation
auto rangesResult = std::ranges::prev_permutation(numbers);
fmt::println("std::ranges::prev_permutation: has prev = {}, permutation = {}",rangesResult.found, numbers);
// 预期输出: std::ranges::prev_permutation: has prev = true, permutation = [3,
// 1, 2]

is_permutation, ranges::is_permutation: 检查两个范围是否为同一排列.

std::vector<int> first = {1, 2, 3};
std::vector<int> second = {3, 2, 1};
// 使用 std::is_permutation
bool stdIsPerm =std::is_permutation(first.begin(), first.end(), second.begin());
fmt::println("std::is_permutation: {}", stdIsPerm);
// 预期输出: std::is_permutation: truefirst = {1, 2, 3};
second = {3, 2, 1};
// 使用 std::ranges::is_permutation
bool rangesIsPerm = std::ranges::is_permutation(first, second);
fmt::println("std::ranges::is_permutation: {}", rangesIsPerm);
// 预期输出: std::ranges::is_permutation: true

数值操作

iota, ranges::iota: 生成递增序列.

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

accumulate: 计算范围内所有元素的累积和.

std::vector<int> numbers = {1, 2, 3, 4, 5};
// 使用 std::accumulate
int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
fmt::println("std::accumulate: {}", sum);
// 输出: std::accumulate: 15

inner_product: 计算两个范围的内积.

std::vector<int> first = {1, 2, 3};
std::vector<int> second = {4, 5, 6};
// 使用 std::inner_product
int product =std::inner_product(first.begin(), first.end(), second.begin(), 0);
fmt::println("std::inner_product: {}", product);
// 输出: std::inner_product: 32

adjacent_difference: 计算范围中相邻元素的差.

std::vector<int> numbers = {1, 3, 6, 10, 15};
std::vector<int> result(5);
// 使用 std::adjacent_difference
std::adjacent_difference(numbers.begin(), numbers.end(), result.begin());
fmt::println("std::adjacent_difference: {}", result);
// 输出: std::adjacent_difference: [1, 2, 3, 4, 5]

partial_sum: 计算范围的部分和.

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> result(5);
// 使用 std::partial_sum
std::partial_sum(numbers.begin(), numbers.end(), result.begin());
fmt::println("std::partial_sum: {}", result);
// 输出: std::partial_sum: [1, 3, 6, 10, 15]

reduce (C++17): 并行计算范围内元素的累积和.

std::vector<int> numbers = {1, 2, 3, 4, 5};
// 使用 std::reduce
int sum = std::reduce(numbers.begin(), numbers.end(), 0);
fmt::println("std::reduce: {}", sum);
// 输出: std::reduce: 15

inclusive_scan: 计算范围的前缀和(包含当前元素).

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> result(5);
// 使用 std::inclusive_scan
std::inclusive_scan(numbers.begin(), numbers.end(), result.begin());
fmt::println("std::inclusive_scan: {}", result);
// 输出: std::inclusive_scan: [1, 3, 6, 10, 15]

exclusive_scan: 计算范围的前缀和(不包含当前元素).

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> result(5);
// 使用 std::exclusive_scan
std::exclusive_scan(numbers.begin(), numbers.end(), result.begin(), 0);
fmt::println("std::exclusive_scan: {}", result);
// 输出: std::exclusive_scan: [0, 1, 3, 6, 10]

transform_reduce: 并行计算范围内元素的累积和, 同时应用变换函数.

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto square = [](int x) { return x * x; };
// 使用 std::transform_reduce
int sumOfSquares = std::transform_reduce(numbers.begin(), numbers.end(), 0,std::plus<>(), square);
fmt::println("std::transform_reduce: {}", sumOfSquares);
// 输出: std::transform_reduce: 55

transform_inclusive_scan: 计算范围的前缀和(包含当前元素), 同时应用变换函数.

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> result(5);
auto square = [](int x) { return x * x; };
// 使用 std::transform_inclusive_scan
std::transform_inclusive_scan(numbers.begin(), numbers.end(), result.begin(),std::plus<>(), square);
fmt::println("std::transform_inclusive_scan: {}", result);
// 输出: std::transform_inclusive_scan: [1, 5, 14, 30, 55]

transform_exclusive_scan: 计算范围的前缀和(不包含当前元素), 同时应用变换函数.

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int> result(5);
auto square = [](int x) { return x * x; };
// 使用 std::transform_exclusive_scan
std::transform_exclusive_scan(numbers.begin(), numbers.end(), result.begin(),0, std::plus<>(), square);
fmt::println("std::transform_exclusive_scan: {}", result);
// 输出: std::transform_exclusive_scan: [0, 1, 5, 14, 30]