演算法庫

演算法庫定義了用於各種目的（例如搜尋、排序、計數、操作）的函式，這些函式作用於元素範圍。請注意，範圍定義為 [first, last)，其中 last 指的是要檢查或修改的最後一個元素“之後”的元素。

[編輯] 約束演算法 (C++20 起)

C++20 在名稱空間 std::ranges 中提供了大多數演算法的約束版本。在這些演算法中，範圍可以指定為迭代器-哨兵對，也可以指定為單個 range 引數，並且支援投影和指向成員的函式物件。此外，大多數演算法的返回型別已更改為返回在演算法執行期間計算的所有潛在有用資訊。

std::vector<int> v{7, 1, 4, 0, -1};
std::ranges::sort(v); // constrained algorithm

[編輯] 執行策略 (C++17 起)

大多數演算法都有接受執行策略的過載。標準庫演算法支援多種執行策略，庫提供了相應的執行策略型別和物件。使用者可以透過呼叫具有相應型別的執行策略物件的並行演算法來靜態選擇執行策略。

標準庫實現（但非使用者）可以定義額外的執行策略作為擴充套件。使用實現定義型別的執行策略物件呼叫的並行演算法的語義是實現定義的。

並行版本的演算法（std::for_each 和 std::for_each_n 除外）允許任意複製範圍中的元素，只要 std::is_trivially_copy_constructible_v<T> 和 std::is_trivially_destructible_v<T> 均為 true，其中 T 是元素的型別。

定義於標頭檔案 `<execution>`
定義於名稱空間 `std::execution`
sequenced_policyparallel_policyparallel_unsequenced_policyunsequenced_policy (C++17)(C++17)(C++17)(C++20)	執行策略型別 (類) [編輯]
seqparpar_unsequnseq (C++17)(C++17)(C++17)(C++20)	全域性執行策略物件 (常量) [編輯]
定義於名稱空間 `std`
is_execution_policy (C++17)	測試一個類是否表示執行策略 (類模板) [編輯]

特性測試宏	值	標準	特性
`__cpp_lib_parallel_algorithm`	`201603L`	(C++17)	並行演算法
`__cpp_lib_execution`	`201603L`	(C++17)	執行策略
`__cpp_lib_execution`	`201902L`	(C++20)	std::execution::unsequenced_policy

[編輯] 非修改序列操作

[編輯] 批處理操作

定義於標頭檔案 `<algorithm>`
for_each	對範圍中的元素應用一元函式物件 (函式模板) [編輯]
ranges::for_each (C++20)	對範圍中的元素應用一元函式物件 (演算法函式物件)[編輯]
for_each_n (C++17)	對序列中的前 N 個元素應用函式物件 (函式模板) [編輯]
ranges::for_each_n (C++20)	對序列中的前 N 個元素應用函式物件 (演算法函式物件)[編輯]

[編輯] 搜尋操作

定義於標頭檔案 `<algorithm>`
all_ofany_ofnone_of (C++11)(C++11)(C++11)	檢查範圍中的所有、任意一個或沒有元素使謂詞為 true (函式模板) [編輯]
ranges::all_ofranges::any_ofranges::none_of (C++20)(C++20)(C++20)	檢查範圍中的所有、任意一個或沒有元素使謂詞為 true (演算法函式物件)[編輯]
ranges::containsranges::contains_subrange (C++23)(C++23)	檢查範圍是否包含給定的元素或子範圍 (演算法函式物件)[編輯]
findfind_iffind_if_not (C++11)	尋找第一個滿足特定條件的元素 (函式模板) [編輯]
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	尋找第一個滿足特定條件的元素 (演算法函式物件)[編輯]
ranges::find_lastranges::find_last_ifranges::find_last_if_not (C++23)(C++23)(C++23)	尋找最後一個滿足特定條件的元素 (演算法函式物件)[編輯]
find_end	在特定範圍中尋找最後一次出現的元素序列 (函式模板) [編輯]
ranges::find_end (C++20)	在特定範圍中尋找最後一次出現的元素序列 (演算法函式物件)[編輯]
find_first_of	搜尋一組元素中的任何一個 (函式模板) [編輯]
ranges::find_first_of (C++20)	搜尋一組元素中的任何一個 (演算法函式物件)[編輯]
adjacent_find	尋找第一對相等的（或滿足給定謂詞的）相鄰項 (函式模板) [編輯]
ranges::adjacent_find (C++20)	尋找第一對相等的（或滿足給定謂詞的）相鄰項 (演算法函式物件)[編輯]
countcount_if	返回滿足特定條件的元素數量 (函式模板) [編輯]
ranges::countranges::count_if (C++20)(C++20)	返回滿足特定條件的元素數量 (演算法函式物件)[編輯]
mismatch	尋找兩個範圍開始不同的第一個位置 (函式模板) [編輯]
ranges::mismatch (C++20)	尋找兩個範圍開始不同的第一個位置 (演算法函式物件)[編輯]
equal	判斷兩組元素是否相同 (函式模板) [編輯]
ranges::equal (C++20)	判斷兩組元素是否相同 (演算法函式物件)[編輯]
search	搜尋一個範圍的元素首次出現的位置 (函式模板) [編輯]
ranges::search (C++20)	搜尋一個範圍的元素首次出現的位置 (演算法函式物件)[編輯]
search_n	在一個範圍內搜尋一個元素的連續 N 次副本首次出現的位置 (函式模板) [編輯]
ranges::search_n (C++20)	在一個範圍內搜尋一個元素的連續 N 次副本首次出現的位置 (演算法函式物件)[編輯]
ranges::starts_with (C++23)	檢查一個範圍是否以另一個範圍開始 (演算法函式物件)[編輯]
ranges::ends_with (C++23)	檢查一個範圍是否以另一個範圍結束 (演算法函式物件)[編輯]

[編輯] 摺疊操作 (C++23 起)

定義於標頭檔案 `<algorithm>`
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)	對一個範圍的元素進行左摺疊，並返回一個 pair (迭代器, 值) (演算法函式物件)[編輯]
ranges::fold_left_first_with_iter (C++23)	使用第一個元素作為初始值對元素範圍進行左摺疊，並返回 pair (迭代器, optional) (演算法函式物件)[編輯]

[編輯] 修改序列操作

[編輯] 複製操作

定義於標頭檔案 `<algorithm>`
copycopy_if (C++11)	將一個範圍的元素複製到一個新位置 (函式模板) [編輯]
ranges::copyranges::copy_if (C++20)(C++20)	將一個範圍的元素複製到一個新位置 (演算法函式物件)[編輯]
copy_n (C++11)	將一定數量的元素複製到一個新位置 (函式模板) [編輯]
ranges::copy_n (C++20)	將一定數量的元素複製到一個新位置 (演算法函式物件)[編輯]
copy_backward	以逆序複製一個範圍的元素 (函式模板) [編輯]
ranges::copy_backward (C++20)	以逆序複製一個範圍的元素 (演算法函式物件)[編輯]
move (C++11)	將一個範圍的元素移動到一個新位置 (函式模板) [編輯]
ranges::move (C++20)	將一個範圍的元素移動到一個新位置 (演算法函式物件)[編輯]
move_backward (C++11)	以逆序將一個範圍的元素移動到一個新位置 (函式模板) [編輯]
ranges::move_backward (C++20)	以逆序將一個範圍的元素移動到一個新位置 (演算法函式物件)[編輯]

[編輯] 交換操作

定義於標頭檔案 `<algorithm>` (C++11 前)
定義於標頭檔案 `<utility>` (C++11 起)
定義於標頭檔案 `<string_view>`
swap	交換兩個物件的值 (函式模板) [編輯]
定義於標頭檔案 `<algorithm>`
swap_ranges	交換兩個範圍的元素 (函式模板) [編輯]
ranges::swap_ranges (C++20)	交換兩個範圍的元素 (演算法函式物件)[編輯]
iter_swap	交換兩個迭代器所指向的元素 (函式模板) [編輯]

[編輯] 轉換操作

定義於標頭檔案 `<algorithm>`
transform	對一個範圍的元素應用函式，並將結果儲存在目標範圍中 (函式模板) [編輯]
ranges::transform (C++20)	對一個範圍的元素應用函式 (演算法函式物件)[編輯]
replacereplace_if	用另一個值替換所有滿足特定條件的值 (函式模板) [編輯]
ranges::replaceranges::replace_if (C++20)(C++20)	用另一個值替換所有滿足特定條件的值 (演算法函式物件)[編輯]
replace_copyreplace_copy_if	複製一個範圍，同時用另一個值替換滿足特定條件的元素 (函式模板) [編輯]
ranges::replace_copyranges::replace_copy_if (C++20)(C++20)	複製一個範圍，同時用另一個值替換滿足特定條件的元素 (演算法函式物件)[編輯]

[編輯] 生成操作

定義於標頭檔案 `<algorithm>`
fill	將給定值複製賦給一個範圍中的每個元素 (函式模板) [編輯]
ranges::fill (C++20)	給一個範圍的元素賦某個值 (演算法函式物件)[編輯]
fill_n	將給定值複製賦給一個範圍中的 N 個元素 (函式模板) [編輯]
ranges::fill_n (C++20)	給一定數量的元素賦一個值 (演算法函式物件)[編輯]
generate	將連續函式呼叫的結果賦給一個範圍中的每個元素 (函式模板) [編輯]
ranges::generate (C++20)	將一個函式的結果儲存在一個範圍中 (演算法函式物件)[編輯]
generate_n	將連續函式呼叫的結果賦給一個範圍中的 N 個元素 (函式模板) [編輯]
ranges::generate_n (C++20)	儲存 N 次應用一個函式的結果 (演算法函式物件)[編輯]

[編輯] 移除操作

定義於標頭檔案 `<algorithm>`
removeremove_if	移除滿足特定標準的元素 (函式模板) [編輯]
ranges::removeranges::remove_if (C++20)(C++20)	移除滿足特定標準的元素 (演算法函式物件)[編輯]
remove_copyremove_copy_if	複製一個範圍的元素，忽略那些滿足特定條件的元素 (函式模板) [編輯]
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	複製一個範圍的元素，忽略那些滿足特定條件的元素 (演算法函式物件)[編輯]
unique	移除一個範圍中的連續重複元素 (函式模板) [編輯]
ranges::unique (C++20)	移除一個範圍中的連續重複元素 (演算法函式物件)[編輯]
unique_copy	建立一個不含連續重複元素的某個元素範圍的副本 (函式模板) [編輯]
ranges::unique_copy (C++20)	建立一個不含連續重複元素的某個元素範圍的副本 (演算法函式物件)[編輯]

[編輯] 改變順序操作

定義於標頭檔案 `<algorithm>`
reverse	反轉一個範圍中元素的順序 (函式模板) [編輯]
ranges::reverse (C++20)	反轉一個範圍中元素的順序 (演算法函式物件)[編輯]
reverse_copy	建立一個反轉後的範圍副本 (函式模板) [編輯]
ranges::reverse_copy (C++20)	建立一個反轉後的範圍副本 (演算法函式物件)[編輯]
rotate	旋轉一個範圍中元素的順序 (函式模板) [編輯]
ranges::rotate (C++20)	旋轉一個範圍中元素的順序 (演算法函式物件)[編輯]
rotate_copy	複製並旋轉一個範圍的元素 (函式模板) [編輯]
ranges::rotate_copy (C++20)	複製並旋轉一個範圍的元素 (演算法函式物件)[編輯]
shift_leftshift_right (C++20)	移動一個範圍中的元素 (函式模板) [編輯]
ranges::shift_leftranges::shift_right (C++23)	移動一個範圍中的元素 (演算法函式物件)[編輯]
random_shuffleshuffle (C++17 前)(C++11)	隨機地重排一個範圍中的元素 (函式模板) [編輯]
ranges::shuffle (C++20)	隨機地重排一個範圍中的元素 (演算法函式物件)[編輯]

[編輯] 取樣操作

定義於標頭檔案 `<algorithm>`
sample (C++17)	從一個序列中選擇 N 個隨機元素 (函式模板) [編輯]
ranges::sample (C++20)	從一個序列中選擇 N 個隨機元素 (演算法函式物件)[編輯]

[編輯] 排序及相關操作

[編輯] 要求

某些演算法要求由引數表示的序列是“已排序”或“已分割槽”的。如果未滿足要求，則行為未定義。

如果對於序列的每個迭代器 iter 和每個非負整數 n（使得 iter + n^[1] 是指向序列元素的有效迭代器），comp(*(iter + n), *iter) == false^[1]，則序列相對於比較器 comp 已排序。

(C++20 前)

如果對於比較器 comp 和投影 proj，序列相對於 comp 和 proj 已排序，則對於序列的每個迭代器 iter 和每個非負整數 n（使得 iter + n^[1] 是指向序列元素的有效迭代器），bool(std::invoke(comp, std::invoke(proj, *(iter + n)),
std::invoke(proj, *iter)))^[1] 為 false。

如果序列相對於 comp 和 std::identity{}（恆等投影）已排序，則序列相對於比較器 comp 已排序。

(C++20 起)

如果存在整數 n，使得對於 [0, std::distance(start, finish)) 中的所有 i，f(*(start + i))^[1] 為 true 當且僅當 i < n，則序列 [start, finish) 相對於表示式 f(e) 已分割槽。

↑ ^1.0 ^1.1 ^1.2 ^1.3 ^1.4 iter + n 簡單地表示“iter 遞增 n 次的結果”，而不管 iter 是否為隨機訪問迭代器。

[編輯] 分割槽操作

定義於標頭檔案 `<algorithm>`
is_partitioned (C++11)	判斷一個範圍是否按給定謂詞劃分 (函式模板) [編輯]
ranges::is_partitioned (C++20)	判斷一個範圍是否按給定謂詞劃分 (演算法函式物件)[編輯]
partition	將一個範圍的元素分成兩組 (函式模板) [編輯]
ranges::partition (C++20)	將一個範圍的元素分成兩組 (演算法函式物件)[編輯]
partition_copy (C++11)	複製一個範圍，並將元素分成兩組 (函式模板) [編輯]
ranges::partition_copy (C++20)	複製一個範圍，並將元素分成兩組 (演算法函式物件)[編輯]
stable_partition	將元素分成兩組，同時保留它們的相對順序 (函式模板) [編輯]
ranges::stable_partition (C++20)	將元素分成兩組，同時保留它們的相對順序 (演算法函式物件)[編輯]
partition_point (C++11)	定位一個已劃分範圍的劃分點 (函式模板) [編輯]
ranges::partition_point (C++20)	定位一個已劃分範圍的劃分點 (演算法函式物件)[編輯]

[編輯] 排序操作

定義於標頭檔案 `<algorithm>`
sort	將一個範圍按升序排序 (函式模板) [編輯]
ranges::sort (C++20)	將一個範圍按升序排序 (演算法函式物件)[編輯]
stable_sort	對一個範圍的元素進行排序，同時保留相等元素之間的順序 (函式模板) [編輯]
ranges::stable_sort (C++20)	對一個範圍的元素進行排序，同時保留相等元素之間的順序 (演算法函式物件)[編輯]
partial_sort	對一個範圍的前 N 個元素進行排序 (函式模板) [編輯]
ranges::partial_sort (C++20)	對一個範圍的前 N 個元素進行排序 (演算法函式物件)[編輯]
partial_sort_copy	複製並部分排序一個範圍的元素 (函式模板) [編輯]
ranges::partial_sort_copy (C++20)	複製並部分排序一個範圍的元素 (演算法函式物件)[編輯]
is_sorted (C++11)	檢查一個範圍是否按升序排序 (函式模板) [編輯]
ranges::is_sorted (C++20)	檢查一個範圍是否按升序排序 (演算法函式物件)[編輯]
is_sorted_until (C++11)	尋找最大的已排序子範圍 (函式模板) [編輯]
ranges::is_sorted_until (C++20)	尋找最大的已排序子範圍 (演算法函式物件)[編輯]
nth_element	部分排序給定的範圍，確保它被給定的元素劃分 (函式模板) [編輯]
ranges::nth_element (C++20)	部分排序給定的範圍，確保它被給定的元素劃分 (演算法函式物件)[編輯]

[編輯] 二分搜尋操作（在分割槽範圍內）

定義於標頭檔案 `<algorithm>`
lower_bound	返回一個指向第一個不小於給定值的元素的迭代器 (函式模板) [編輯]
ranges::lower_bound (C++20)	返回一個指向第一個不小於給定值的元素的迭代器 (演算法函式物件)[編輯]
upper_bound	返回一個指向第一個大於某個值的元素的迭代器 (函式模板) [編輯]
ranges::upper_bound (C++20)	返回一個指向第一個大於某個值的元素的迭代器 (演算法函式物件)[編輯]
equal_range	返回與特定鍵匹配的元素範圍 (函式模板) [編輯]
ranges::equal_range (C++20)	返回與特定鍵匹配的元素範圍 (演算法函式物件)[編輯]
binary_search	判斷一個元素是否存在於部分有序的範圍中 (函式模板) [編輯]
ranges::binary_search (C++20)	判斷一個元素是否存在於部分有序的範圍中 (演算法函式物件)[編輯]

[編輯] 集合操作（在排序範圍內）

定義於標頭檔案 `<algorithm>`
includes	如果一個序列是另一個序列的子序列，則返回 true (函式模板) [編輯]
ranges::includes (C++20)	如果一個序列是另一個序列的子序列，則返回 true (演算法函式物件)[編輯]
set_union	計算兩個集合的並集 (函式模板) [編輯]
ranges::set_union (C++20)	計算兩個集合的並集 (演算法函式物件)[編輯]
set_intersection	計算兩個集合的交集 (函式模板) [編輯]
ranges::set_intersection (C++20)	計算兩個集合的交集 (演算法函式物件)[編輯]
set_difference	計算兩個集合的差集 (函式模板) [編輯]
ranges::set_difference (C++20)	計算兩個集合的差集 (演算法函式物件)[編輯]
set_symmetric_difference	計算兩個集合的對稱差 (函式模板) [編輯]
ranges::set_symmetric_difference (C++20)	計算兩個集合的對稱差 (演算法函式物件)[編輯]

[編輯] 合併操作（在排序範圍內）

定義於標頭檔案 `<algorithm>`
merge	歸併兩個已排序的範圍 (函式模板) [編輯]
ranges::merge (C++20)	歸併兩個已排序的範圍 (演算法函式物件)[編輯]
inplace_merge	就地歸併兩個有序範圍 (函式模板) [編輯]
ranges::inplace_merge (C++20)	就地歸併兩個有序範圍 (演算法函式物件)[編輯]

[編輯] 堆操作

如果對於 (0, last - first) 中的所有整數 i，bool(comp(first[(i - 1) / 2], first[i])) 為 false，則隨機訪問範圍 [first, last) 相對於比較器 comp 是堆。

(C++20 前)

如果對於比較器 comp 和投影 proj，隨機訪問範圍 [first, last) 相對於 comp 和 proj 是堆，則對於 (0, last - first) 中的所有整數 i，bool(std::invoke(comp, std::invoke(proj, first[(i - 1) / 2]),
std::invoke(proj, first[i])) 為 false。

如果範圍相對於 comp 和 std::identity{}（恆等投影）是堆，則隨機訪問範圍 [first, last) 相對於比較器 comp 是堆。

(C++20 起)

堆可以透過 std::make_heap 和 ranges::make_heap(C++20 起) 建立。

有關堆的更多屬性，請參見最大堆。

定義於標頭檔案 `<algorithm>`
push_heap	向一個最大堆新增一個元素 (函式模板) [編輯]
ranges::push_heap (C++20)	向一個最大堆新增一個元素 (演算法函式物件)[編輯]
pop_heap	從一個最大堆中移除最大的元素 (函式模板) [編輯]
ranges::pop_heap (C++20)	從一個最大堆中移除最大的元素 (演算法函式物件)[編輯]
make_heap	從一個元素範圍建立一個最大堆 (函式模板) [編輯]
ranges::make_heap (C++20)	從一個元素範圍建立一個最大堆 (演算法函式物件)[編輯]
sort_heap	將一個最大堆轉換成一個按升序排序的元素範圍 (函式模板) [編輯]
ranges::sort_heap (C++20)	將一個最大堆轉換成一個按升序排序的元素範圍 (演算法函式物件)[編輯]
is_heap (C++11)	檢查給定的範圍是否是一個最大堆 (函式模板) [編輯]
ranges::is_heap (C++20)	檢查給定的範圍是否是一個最大堆 (演算法函式物件)[編輯]
is_heap_until (C++11)	尋找是一個最大堆的最大子範圍 (函式模板) [編輯]
ranges::is_heap_until (C++20)	尋找是一個最大堆的最大子範圍 (演算法函式物件)[編輯]

[編輯] 最小/最大操作

定義於標頭檔案 `<algorithm>`
max	返回給定值中較大的那個 (函式模板) [編輯]
ranges::max (C++20)	返回給定值中較大的那個 (演算法函式物件)[編輯]
max_element	返回一個範圍中最大的元素 (函式模板) [編輯]
ranges::max_element (C++20)	返回一個範圍中最大的元素 (演算法函式物件)[編輯]
min	返回給定值中較小的那個 (函式模板) [編輯]
ranges::min (C++20)	返回給定值中較小的那個 (演算法函式物件)[編輯]
min_element	返回一個範圍中最小的元素 (函式模板) [編輯]
ranges::min_element (C++20)	返回一個範圍中最小的元素 (演算法函式物件)[編輯]
minmax (C++11)	返回兩個元素中較小和較大的一個 (函式模板) [編輯]
ranges::minmax (C++20)	返回兩個元素中較小和較大的一個 (演算法函式物件)[編輯]
minmax_element (C++11)	返回範圍中最小和最大的元素 (函式模板) [編輯]
ranges::minmax_element (C++20)	返回範圍中最小和最大的元素 (演算法函式物件)[編輯]
clamp (C++17)	將值限制在邊界值對之間 (函式模板) [編輯]
ranges::clamp (C++20)	將值限制在邊界值對之間 (演算法函式物件)[編輯]

[編輯] 字典序比較操作

定義於標頭檔案 `<algorithm>`
lexicographical_compare	如果一個範圍在字典上小於另一個範圍，則返回 true (函式模板) [編輯]
ranges::lexicographical_compare (C++20)	如果一個範圍在字典上小於另一個範圍，則返回 true (演算法函式物件)[編輯]
lexicographical_compare_three_way (C++20)	使用三路比較比較兩個範圍 (函式模板) [編輯]

[編輯] 排列操作

定義於標頭檔案 `<algorithm>`
next_permutation	生成元素範圍的下一個更大的字典序排列 (函式模板) [編輯]
ranges::next_permutation (C++20)	生成元素範圍的下一個更大的字典序排列 (演算法函式物件)[編輯]
prev_permutation	生成元素範圍的下一個更小的字典序排列 (函式模板) [編輯]
ranges::prev_permutation (C++20)	生成元素範圍的下一個更小的字典序排列 (演算法函式物件)[編輯]
is_permutation (C++11)	確定一個序列是否是另一個序列的排列 (函式模板) [編輯]
ranges::is_permutation (C++20)	確定一個序列是否是另一個序列的排列 (演算法函式物件)[編輯]

[編輯] 數值操作

定義於標頭檔案 `<numeric>`
iota (C++11)	以起始值的連續增量填充一個範圍 (函式模板) [編輯]
ranges::iota (C++23)	以起始值的連續增量填充一個範圍 (演算法函式物件)[編輯]
accumulate	對一個範圍的元素進行求和或摺疊 (函式模板) [編輯]
inner_product	計算兩個元素範圍的內積 (函式模板) [編輯]
adjacent_difference	計算一個範圍內相鄰元素之間的差值 (函式模板) [編輯]
partial_sum	計算一個範圍元素的部分和 (函式模板) [編輯]
reduce (C++17)	類似於 std::accumulate，但順序是亂序的 (函式模板) [編輯]
exclusive_scan (C++17)	類似於 std::partial_sum，將第 $i$ 個輸入元素從第 $i$ 個和中排除 (函式模板) [編輯]
inclusive_scan (C++17)	類似於 std::partial_sum，將第 $i$ 個輸入元素包含在第 $i$ 個和中 (函式模板) [編輯]
transform_reduce (C++17)	應用一個可呼叫物件，然後進行亂序歸約 (函式模板) [編輯]
transform_exclusive_scan (C++17)	應用一個可呼叫物件，然後計算排除掃描 (函式模板) [編輯]
transform_inclusive_scan (C++17)	應用一個可呼叫物件，然後計算包含掃描 (函式模板) [編輯]

[編輯] 未初始化記憶體上的操作

定義於標頭檔案 `<memory>`
uninitialized_copy	將物件範圍複製到未初始化記憶體區域 (函式模板) [編輯]
ranges::uninitialized_copy (C++20)	將物件範圍複製到未初始化記憶體區域 (演算法函式物件)[編輯]
uninitialized_copy_n (C++11)	將一定數量的物件複製到未初始化記憶體區域 (函式模板) [編輯]
ranges::uninitialized_copy_n (C++20)	將一定數量的物件複製到未初始化記憶體區域 (演算法函式物件)[編輯]
uninitialized_fill	將物件複製到由範圍定義的未初始化記憶體區域 (函式模板) [編輯]
ranges::uninitialized_fill (C++20)	將物件複製到由範圍定義的未初始化記憶體區域 (演算法函式物件)[編輯]
uninitialized_fill_n	將物件複製到由起始和計數定義的未初始化記憶體區域 (函式模板) [編輯]
ranges::uninitialized_fill_n (C++20)	將物件複製到由起始和計數定義的未初始化記憶體區域 (演算法函式物件)[編輯]
uninitialized_move (C++17)	將一系列物件移動到未初始化記憶體區域 (函式模板) [編輯]
ranges::uninitialized_move (C++20)	將一系列物件移動到未初始化記憶體區域 (演算法函式物件)[編輯]
uninitialized_move_n (C++17)	將多個物件移動到未初始化記憶體區域 (函式模板) [編輯]
ranges::uninitialized_move_n (C++20)	將多個物件移動到未初始化記憶體區域 (演算法函式物件)[編輯]
uninitialized_default_construct (C++17)	透過預設初始化在由範圍定義的未初始化記憶體區域中構造物件 (函式模板) [編輯]
ranges::uninitialized_default_construct (C++20)	透過預設初始化在由範圍定義的未初始化記憶體區域中構造物件 (演算法函式物件)[編輯]
uninitialized_default_construct_n (C++17)	在由起始和計數定義的未初始化記憶體區域中，透過預設初始化構造物件 (函式模板) [編輯]
ranges::uninitialized_default_construct_n (C++20)	透過預設初始化在由起始和計數定義的未初始化記憶體區域中構造物件 (演算法函式物件)[編輯]
uninitialized_value_construct (C++17)	在由範圍定義的未初始化記憶體區域中，透過值初始化構造物件 (函式模板) [編輯]
ranges::uninitialized_value_construct (C++20)	在由範圍定義的未初始化記憶體區域中，透過值初始化構造物件 (演算法函式物件)[編輯]
uninitialized_value_construct_n (C++17)	在由起始和計數定義的未初始化記憶體區域中，透過值初始化構造物件 (函式模板) [編輯]
ranges::uninitialized_value_construct_n (C++20)	在由起始和計數定義的未初始化記憶體區域中，透過值初始化構造物件 (演算法函式物件)[編輯]
destroy (C++17)	銷燬物件範圍 (函式模板) [編輯]
ranges::destroy (C++20)	銷燬物件範圍 (演算法函式物件)[編輯]
destroy_n (C++17)	銷燬範圍內的多個物件 (函式模板) [編輯]
ranges::destroy_n (C++20)	銷燬範圍內的多個物件 (演算法函式物件)[編輯]
destroy_at (C++17)	銷燬給定地址處的物件 (函式模板) [編輯]
ranges::destroy_at (C++20)	銷燬給定地址處的物件 (演算法函式物件)[編輯]
construct_at (C++20)	在給定地址建立物件 (函式模板) [編輯]
ranges::construct_at (C++20)	在給定地址建立物件 (演算法函式物件)[編輯]

[編輯] 隨機數生成 (自 C++26 起)

定義於標頭檔案 `<random>`
ranges::generate_random (C++26)	用來自均勻隨機位生成器的隨機數填充範圍 (演算法函式物件)[編輯]

[編輯] 注意

特性測試宏	值	標準	特性
`__cpp_lib_algorithm_iterator_requirements`	`202207L`	(C++23)	Ranges 迭代器作為非 Ranges 演算法的輸入
`__cpp_lib_clamp`	`201603L`	(C++17)	std::clamp
`__cpp_lib_constexpr_algorithms`	`201806L`	(C++20)	演算法的 constexpr
`__cpp_lib_constexpr_algorithms`	`202306L`	(C++26)	constexpr 穩定排序
`__cpp_lib_algorithm_default_value_type`	`202403L`	(C++26)	演算法的列表初始化
`__cpp_lib_freestanding_algorithm`	`202311L`	(C++26)	`<algorithm>` 中的獨立設施
`__cpp_lib_robust_nonmodifying_seq_ops`	`201304L`	(C++14)	使非修改序列操作更健壯（std::mismatch、std::equal 和 std::is_permutation 的雙範圍過載）
`__cpp_lib_sample`	`201603L`	(C++17)	std::sample
`__cpp_lib_shift`	`201806L`	(C++20)	std::shift_left 和 std::shift_right

[編輯] C 庫

定義於標頭檔案 `<cstdlib>`
qsort	對未指定型別的元素範圍進行排序 (函式) [編輯]
bsearch	在陣列中搜索未指定型別的元素 (函式) [編輯]

[編輯] 缺陷報告

下列更改行為的缺陷報告追溯地應用於以前出版的 C++ 標準。

缺陷報告	應用於	釋出時的行為	正確的行為
LWG 193	C++98	堆要求 *first 是最大元素	可能存在等於 *first 的元素
LWG 2150	C++98	排序序列的定義不正確	已更正
LWG 2166	C++98	堆要求與最大堆的定義不夠匹配	要求已改進

[編輯] 另請參閱

C 文件，關於演算法

[plus-1] 1.0 ^1.1 ^1.2 ^1.3 ^1.4 iter + n 簡單地表示“iter 遞增 n 次的結果”，而不管 iter 是否為隨機訪問迭代器。

[1]

編譯器支援
自由（freestanding）與宿主（hosted）
語言
標準庫
標準庫標頭檔案
具名要求
特性測試宏 (C++20)
語言支援庫
概念庫 (C++20)
診斷庫
記憶體管理庫
超程式設計庫 (C++11)
通用工具庫
容器庫
迭代器庫
範圍庫 (C++20)
演算法庫
字串庫
文字處理庫
數值庫
日期和時間庫
輸入/輸出庫
檔案系統庫 (C++17)
併發支援庫 (C++11)
執行控制庫 (C++26)
技術規範
符號索引
外部庫

cppreference.com

名稱空間

變體

檢視

操作