<algorithm>函式</algorithm>
如需 Visual Studio 2017 的最新文件請參閱 Visual Studio 2017 文件。
| <alg>移動 | adjacent_find | all_of |
| any_of | binary_search | 複製 |
| copy_backward | copy_if | copy_n |
| 計數 | count_if | 等於 |
| equal_range | 填滿 | fill_n |
| 尋找 | find_end | find_first_of |
| find_if | find_if_not | for_each |
| 產生 | generate_n | 包含 |
| inplace_merge | is_heap | is_heap_until |
| is_partitioned | is_permutation | is_sorted |
| is_sorted_until | iter_swap | lexicographical_compare |
| lower_bound | make_heap | 最大值 |
| max_element | 合併 | 最小值 |
| min_element | minmax | minmax_element |
| 不相符 | move_backward | next_permutation |
| none_of | nth_element | partial_sort |
| partial_sort_copy | 資料分割 | partition_copy |
| partition_point | pop_heap | prev_permutation |
| push_heap | random_shuffle | remove |
| remove_copy | remove_copy_if | remove_if |
| 取代 | replace_copy | replace_copy_if |
| replace_if | 反向 | reverse_copy |
| 旋轉 | rotate_copy | 搜尋 |
| search_n | set_difference | set_intersection |
| set_symmetric_difference | set_union | 排序 |
| sort_heap | stable_partition | stable_sort |
| std:: shuffle | 交換 | swap_ranges |
| 轉換 | 唯一 | unique_copy |
| upper_bound |
adjacent_find
搜尋等於或符合指定之條件的兩個相鄰項目。
template<class ForwardIterator>
ForwardIterator adjacent_find(
ForwardIterator _First,
ForwardIterator _Last);
template<class ForwardIterator , class BinaryPredicate>
ForwardIterator adjacent_find(
ForwardIterator _First,
ForwardIterator _Last,
BinaryPredicate _Comp);
參數
_First
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
_Last
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
_Comp
二元述詞提供所搜尋的範圍中相鄰元素的值要符合的條件。
傳回值
等於彼此 (在第一版中)，或符合二元述詞所指定條件 (在第二個版本中，且前提是找不到此類元素配對) 之相鄰的配對的第一個元素的正向迭代器。 否則則是指向 _Last 的迭代器。
備註
adjacent_find 演算法是非變化的序列演算法。 要搜尋的範圍必須有效；所有指標都必須可以取值，而且可透過遞增從第一個位置到達最後一個位置。 演算法的時間複雜性，在範圍內包含的元素數目中是線性。
operator== 用來決定元素間的比對，是否必須施加其運算元之間的對等關聯。
範例
// alg_adj_fnd.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>
// Returns whether second element is twice the first
bool twice (int elem1, int elem2 )
{
return elem1 * 2 == elem2;
}
int main()
{
using namespace std;
list <int> L;
list <int>::iterator Iter;
list <int>::iterator result1, result2;
L.push_back( 50 );
L.push_back( 40 );
L.push_back( 10 );
L.push_back( 20 );
L.push_back( 20 );
cout << "L = ( " ;
for ( Iter = L.begin( ) ; Iter != L.end( ) ; Iter++ )
cout << *Iter << " ";
cout << ")" << endl;
result1 = adjacent_find( L.begin( ), L.end( ) );
if ( result1 == L.end( ) )
cout << "There are not two adjacent elements that are equal."
<< endl;
else
cout << "There are two adjacent elements that are equal."
<< "\n They have a value of "
<< *( result1 ) << "." << endl;
result2 = adjacent_find( L.begin( ), L.end( ), twice );
if ( result2 == L.end( ) )
cout << "There are not two adjacent elements where the "
<< " second is twice the first." << endl;
else
cout << "There are two adjacent elements where "
<< "the second is twice the first."
<< "\n They have values of " << *(result2++);
cout << " & " << *result2 << "." << endl;
}
L = ( 50 40 10 20 20 )
There are two adjacent elements that are equal.
They have a value of 20.
There are two adjacent elements where the second is twice the first.
They have values of 10 & 20.
all_of
當條件出現在指定的範圍中的每個項目時，傳回 true。
template<class InputIterator, class Predicate>
bool all_of(
InputIterator_First,
InputIterator_Last,
BinaryPredicate_Comp);
參數
_First
輸入迭代器，表示要開始檢查條件。 迭代器標記的項目開始的範圍。
_Last
輸入迭代器，表示要檢查符合條件的項目範圍的結尾。
_Comp
若要測試的條件。 這是要檢查的項目應符合條件定義為使用者定義的述詞函式物件。 述詞會採用單一引數並傳回true或false。
傳回值
傳回true如果偵測到條件中指定的範圍，每個項目和false如果條件未偵測到至少一次。
備註
樣板函式傳回true才，每個N範圍[0,Last - _First)，述詞_Comp(*(_First + N))是true。
any_of
當條件出現在指定的項目範圍至少一次時，傳回 true。
template<class InputIterator, class UnaryPredicate>
bool any_of(
InputIterator _First,
InputIterator _Last,
UnaryPredicate _Comp);
參數
_First
輸入迭代器，表示要檢查符合條件的項目範圍。
_Last
輸入迭代器，表示要檢查符合條件的項目範圍的結尾。
_Comp
若要測試的條件。 這被提供使用者定義的述詞函式物件。 述詞定義符合項目所測試的條件。 述詞會採用單一引數並傳回true或false。
傳回值
傳回true條件中偵測到至少一次指定範圍中，如果false條件永遠不會偵測到。
備註
樣板函式傳回true才，某些N範圍中
[0, _Last - _First``)，述詞_Comp``(*(``_First``+ N))為 true。
binary_search
測試已排序的範圍中是否有等於指定之值 (或在二元述詞指定的意義上，相當於該值) 的項目。
template<class ForwardIterator, class Type>
bool binary_search(
ForwardIterator first,
ForwardIterator last,
const Type& value);
template<class ForwardIterator, class Type, class BinaryPredicate>
bool binary_search(
ForwardIterator first,
ForwardIterator last,
const Type& value,
BinaryPredicate comp);
參數
first
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
last
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
value
必要的項目值要比對的值或二元述詞指定的項目值必須符合條件。
comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數並傳回true符合時則和false不符合時。
傳回值
true如果在相同或相當於指定的值，範圍內找到的項目否則， false。
備註
參考的排序的來源範圍必須有效;所有指標都必須都可以取值，且在序列中，最後一個位置必須都要可以從第一個可透過遞增。
已排序的範圍必須每個排列應用程式的前提binary_search根據相同的排序方式為演算法會使用演算法來排序合併的範圍。
來源範圍不會修改binary_search。
正向迭代器的實值型別必須為小於-比比較排序，以便提供兩個項目，可以判斷它們相等 （中都不小於另的意義） 或是其中一個是小於另。 這會導致非對等元件之間的排序
演算法的複雜度是對數隨機存取迭代器和線性比例的步驟數目與否則 ( last – first)。
範例
// alg_bin_srch.cpp
// compile with: /EHsc
#include <list>
#include <vector>
#include <algorithm>
#include <functional> // greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser( int elem1, int elem2 )
{
if (elem1 < 0)
elem1 = - elem1;
if (elem2 < 0)
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
list <int> List1;
List1.push_back( 50 );
List1.push_back( 10 );
List1.push_back( 30 );
List1.push_back( 20 );
List1.push_back( 25 );
List1.push_back( 5 );
List1.sort();
cout << "List1 = ( " ;
for ( auto Iter : List1 )
cout << Iter << " ";
cout << ")" << endl;
// default binary search for 10
if( binary_search(List1.begin(), List1.end(), 10) )
cout << "There is an element in list List1 with a value equal to 10."
<< endl;
else
cout << "There is no element in list List1 with a value equal to 10."
<< endl;
// a binary_search under the binary predicate greater
List1.sort(greater<int>());
if( binary_search(List1.begin(), List1.end(), 10, greater<int>()) )
cout << "There is an element in list List1 with a value greater than 10 "
<< "under greater than." << endl;
else
cout << "No element in list List1 with a value greater than 10 "
<< "under greater than." << endl;
// a binary_search under the user-defined binary predicate mod_lesser
vector<int> v1;
for( auto i = -2; i <= 4; ++i )
{
v1.push_back(i);
}
sort(v1.begin(), v1.end(), mod_lesser);
cout << "Ordered using mod_lesser, vector v1 = ( " ;
for( auto Iter : v1 )
cout << Iter << " ";
cout << ")" << endl;
if( binary_search(v1.begin(), v1.end(), -3, mod_lesser) )
cout << "There is an element with a value equivalent to -3 "
<< "under mod_lesser." << endl;
else
cout << "There is not an element with a value equivalent to -3 "
<< "under mod_lesser." << endl;
}
複製
從來源範圍將項目的值指定到目的範圍，逐一查看項目的來源序列，並以正向方向指派它們新位置。
template<class InputIterator, class OutputIterator>
OutputIterator copy(
InputIterator _First,
InputIterator _Last,
OutputIterator _DestBeg);
參數
_First
輸入迭代器，在來源範圍的第一個項目位置定址。
_Last
輸入迭代器，用於定址來源範圍中最後一個項目的後面一個位置。
_DestBeg
輸出迭代器，用於定址目的範圍中第一個項目的位置。
傳回值
輸出迭代器，也就是其中一個過去的目標範圍中最後一個項目的位置定址，迭代器定址_Result+ ( _Last – _First )。
備註
來源範圍必須是有效的，而且必須在目的端有足夠的空間保留所有項目的複本。
因為演算法從第一個項目開始依序複製來源項目，如果來源範圍的 _Last 位置不包含在目的範圍中，目的範圍與來源範圍可以重疊。 除非來源和目的範圍之間沒有重疊，copy 可以用來將項目向左移，而不是向右移。 若要向右移位任何數目的位置，請使用copy_backward演算法。
copy 演算法只修改迭代器指向的值，並指派新值給目的範圍的項目。 它不是用來建立新的項目，也不能直接將項目插入空的容器。
範例
// alg_copy.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 0 ; i <= 5 ; i++ )
v1.push_back( 10 * i );
int ii;
for ( ii = 0 ; ii <= 10 ; ii++ )
v2.push_back( 3 * ii );
cout << "v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
cout << "v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// To copy the first 3 elements of v1 into the middle of v2
copy( v1.begin( ), v1.begin( ) + 3, v2.begin( ) + 4 );
cout << "v2 with v1 insert = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// To shift the elements inserted into v2 two positions
// to the left
copy( v2.begin( )+4, v2.begin( ) + 7, v2.begin( ) + 2 );
cout << "v2 with shifted insert = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
}
如需其他範例，示範如何使用 [複製]，請參閱accumulate、 copy 和 vector:: push_back。
v1 = ( 0 10 20 30 40 50 )
v2 = ( 0 3 6 9 12 15 18 21 24 27 30 )
v2 with v1 insert = ( 0 3 6 9 0 10 20 21 24 27 30 )
v2 with shifted insert = ( 0 3 0 10 20 10 20 21 24 27 30 )
copy_backward
從來源範圍將項目的值指定到目的範圍，逐一查看項目的來源序列，並以反向方向指派它們新位置。
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward(
BidirectionalIterator1 _First,
BidirectionalIterator1 _Last,
BidirectionalIterator2 _DestEnd);
參數
_First
雙向迭代器，在來源範圍的第一個項目位置定址。
_Last
雙向迭代器，在來源範圍中越過最後一個項目的位置定址。
_DestEnd
雙向迭代器，在目的範圍中越過最後一個項目的位置定址。
傳回值
輸出迭代器，也就是其中一個過去的目標範圍中最後一個項目的位置定址，迭代器定址_DestEnd– ( _Last – _First )。
備註
來源範圍必須是有效的，而且必須在目的端有足夠的空間保留所有項目的複本。
copy_backward 演算法較複製演算法強加更嚴格的需求。 其輸入和輸出迭代器必須是雙向的。
copy_backward和move_backward演算法是會指定輸出範圍並迭代器指向目的範圍結尾的標準樣板程式庫演算法。
因為演算法從最後一個項目開始依序複製來源項目，如果來源範圍的 _First 位置不包含在目的範圍中，目的範圍與來源範圍可以重疊。 除非來源和目的範圍之間沒有重疊，copy_backward 可以用來將項目向右位移，而不是向左移。 若要向左移動任何數目的位置，請使用複製演算法。
copy_backward 演算法只修改迭代器指向的值，並指派新值給目的範圍的項目。 它不是用來建立新的項目，也不能直接將項目插入空的容器。
範例
// alg_copy_bkwd.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 0 ; i <= 5 ; ++i )
v1.push_back( 10 * i );
int ii;
for ( ii = 0 ; ii <= 10 ; ++ii )
v2.push_back( 3 * ii );
cout << "v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; ++Iter1 )
cout << *Iter1 << " ";
cout << ")" << endl;
cout << "v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; ++Iter2 )
cout << *Iter2 << " ";
cout << ")" << endl;
// To copy_backward the first 3 elements of v1 into the middle of v2
copy_backward( v1.begin( ), v1.begin( ) + 3, v2.begin( ) + 7 );
cout << "v2 with v1 insert = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; ++Iter2 )
cout << *Iter2 << " ";
cout << ")" << endl;
// To shift the elements inserted into v2 two positions
// to the right
copy_backward( v2.begin( )+4, v2.begin( ) + 7, v2.begin( ) + 9 );
cout << "v2 with shifted insert = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; ++Iter2 )
cout << *Iter2 << " ";
cout << ")" << endl;
}
copy_if
在範圍中的項目，將複製的項目true針對指定的條件。
template<class InputIterator, class OutputIterator, class BinaryPredicate>
OutputIterator copy_if(
InputIterator _First,
InputIterator _Last,
OutputIterator _Dest,
Predicate _Pred);
參數
_First
輸入迭代器，表示要檢查的條件之範圍開頭。
_Last
輸入迭代器，指出範圍的結尾。
_Dest
輸出迭代器，指出複製項目的目的端。
_Pred
每個項目範圍中的測試條件。 這種狀況會提供使用者定義的述詞函式物件。 述詞會採用一個引數，並傳回true或false。
傳回值
輸出迭代器等於_Dest遞增後，每個項目可滿足條件。 換句話說，傳回的值減去_Dest等於複製的項目數目。
備註
樣板函式評估
if (_Pred(*_First + N)) * _Dest++ = *(_First + N))
每個N範圍[0, _Last - _First)，嚴格地增加值N從最低值開始。 如果_Dest和_First指定儲存區域，_Dest不能在範圍[``_First``, _Last``)。
copy_n
複製指定的項目數目。
template<class InputIterator, class Size, class OutputIterator>
OutputIterator copy_n(
InputIterator first,
Size count,
OutputIterator dest);
參數
first
輸入迭代器，表示要複製元素的位置。
count
帶正負號或不帶正負號的整數類型，指定要複製的元素數目。
dest
輸出迭代器，表示要將元素複製過去的位置。
傳回值
傳回輸出迭代器，其中已將元素複製過去。 它和第三個參數 dest 的傳回值相同。
備註
範本函式會評估*(dest + N) = *(first + N))每個N範圍中[0, count``)，嚴格地增加值N從最低值開始。 它接著會傳回dest + N。 如果dest和first指定儲存區域，dest不能在範圍[``first``, Last``)。
計數
傳回範圍中值符合指定值的項目數目。
template<class InputIterator, class Type>
typename iterator_traits<InputIterator>::difference_type count(
InputIterator _First,
InputIterator _Last,
const Type& _Val);
參數
_First
輸入迭代器定址範圍中的第一個項目的位置周遊。
_Last
輸入迭代器定址超過一個位置的最終項目範圍中周遊。
_Val
要計算之項目的值。
傳回值
差異類型InputIterator ，計算範圍中的項目數 [ _First， _Last )] 值_Val。
備註
operator== 用來決定元素及指定值間的比對，是否必須施加其運算元之間的等價關聯。
此演算法會計算符合任何與樣板函式的述詞的項目一般化count_if。
範例
// alg_count.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main()
{
using namespace std;
vector<int> v1;
vector<int>::iterator Iter;
v1.push_back(10);
v1.push_back(20);
v1.push_back(10);
v1.push_back(40);
v1.push_back(10);
cout << "v1 = ( " ;
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
cout << *Iter << " ";
cout << ")" << endl;
vector<int>::iterator::difference_type result;
result = count(v1.begin(), v1.end(), 10);
cout << "The number of 10s in v2 is: " << result << "." << endl;
}
v1 = ( 10 20 10 40 10 )
The number of 10s in v2 is: 3.
count_if
傳回值符合指定的條件的範圍中的項目數目。
template<class InputIterator, class Predicate>
typename iterator_traits<InputIterator>::difference_type count_if(
InputIterator _First,
InputIterator _Last,
Predicate _Pred);
參數
_First
輸入迭代器，其定址要搜尋範圍中第一個元素的位置。
_Last
輸入迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
_Pred
定義要在計算項目是否符合條件的使用者定義的述詞函式物件。 述詞會採用單一引數並傳回true或false。
傳回值
滿足述詞所指定之條件的項目數目。
備註
這個範本函式是演算法的一般化計數，取代述詞 「 等於特定值 」 任意述詞。
範例
// alg_count_if.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
bool greater10(int value)
{
return value >10;
}
int main()
{
using namespace std;
vector<int> v1;
vector<int>::iterator Iter;
v1.push_back(10);
v1.push_back(20);
v1.push_back(10);
v1.push_back(40);
v1.push_back(10);
cout << "v1 = ( ";
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
cout << *Iter << " ";
cout << ")" << endl;
vector<int>::iterator::difference_type result1;
result1 = count_if(v1.begin(), v1.end(), greater10);
cout << "The number of elements in v1 greater than 10 is: "
<< result1 << "." << endl;
}
v1 = ( 10 20 10 40 10 )
The number of elements in v1 greater than 10 is: 2.
等於
逐一比較兩個範圍的每個項目是否相等 (或在二元述詞指定的意義上，是否對等)。
使用std::equal比較在不同的容器類型中的項目時 (例如vector和list) 或比較不同的項目類型時，或如果您要比較的容器的子範圍。 否則，在比較中相同的容器型別的相同類型的項目時，請使用非成員operator==提供每個容器。
使用 C++14 程式碼中的雙重範圍多載，因為如果第二個範圍超過第一個範圍，只為第二個範圍採用單一迭代器的多載不會偵測到差異；而如果第二個範圍比第一個範圍短，則會導致未定義的行為。
template<class InputIterator1, class InputIterator2>
bool equal(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2,
BinaryPredicate Comp); // C++14
template<class InputIterator1, class InputIterator2>
bool equal(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2,
InputIterator2 Last2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2,
InputIterator2 Last2,
BinaryPredicate Comp);
參數
First1
輸入迭代器，定址要測試的第一個範圍中第一個項目的位置。
Last1
輸入迭代器，定址要測試的第一個範圍中最後一個項目的後面一個位置。
First2
輸入迭代器，定址要測試的第二個範圍中第一個項目的位置。
First2
輸入迭代器，定址要測試的第二個範圍中最後一個項目的後面一個位置。
Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
true才的範圍是相同或等於二元述詞的項目，否則相較下false。
備註
要搜尋的範圍必須有效；所有迭代器都必須可以取值，而且可透過遞增從第一個位置到達最後一個位置。
如果兩個範圍有相等的長度，則演算法的時間複雜性，在範圍包含的項目數目中是線性。 否則函式立即傳回 false。
operator== 和使用者定義的述詞不需要在運算元之間強加對稱、自反和遞移的等價關係。
範例
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
vector<int> v1 { 0, 5, 10, 15, 20, 25 };
vector<int> v2 { 0, 5, 10, 15, 20, 25 };
vector<int> v3 { 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 };
// Using range-and-a-half equal:
bool b = equal(v1.begin(), v1.end(), v2.begin());
cout << "v1 and v2 are equal: "
<< b << endl; // true, as expected
b = equal(v1.begin(), v1.end(), v3.begin());
cout << "v1 and v3 are equal: "
<< b << endl; // true, surprisingly
// Using dual-range equal:
b = equal(v1.begin(), v1.end(), v3.begin(), v3.end());
cout << "v1 and v3 are equal with dual-range overload: "
<< b << endl; // false
return 0;
}
equal_range
指定的已排序的範圍，會尋找的子範圍中所有元素都是相當於指定的值。
template<class ForwardIterator, class Type>
pair<ForwardIterator, ForwardIterator> equal_range(
ForwardIterator first,
ForwardIterator last,
const Type& val);
template<class ForwardIterator, class Type, class Predicate>
pair<ForwardIterator, ForwardIterator> equal_range(
ForwardIterator first,
ForwardIterator last,
const Type& val,
Predicate comp);
參數
first
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
last
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
val
在已排序的範圍中要搜尋的值。
comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。
傳回值
正向迭代器指定子範圍，搜尋，在範圍內所包含的所有項目是相當於一組val使用二元述詞所定義的意義 (可能是comp或預設值，小於-比)。
如果範圍中的沒有項目相當於val，正向迭代器傳回的 pair 相等，且指定的點位置val可能不會干擾範圍的順序插入。
備註
將演算法傳回的配對的第一個迭代器是lower_bound，和第二個迭代器是upper_bound。
範圍必須根據提供的述詞來排序equal_range。 例如，如果您要使用大於-必須以遞減順序排序的述詞，比範圍。
對所傳回的迭代器所定義的可能是空的子範圍中的項目equal_range就相當於val使用述詞所定義的意義。
演算法的複雜度是對數隨機存取迭代器和線性比例的步驟數目與否則 ( last – first)。
範例
// alg_equal_range.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // greater<int>()
#include <iostream>
#include <string>
using namespace std;
template<class T> void dump_vector( const vector<T>& v, pair< typename vector<T>::iterator, typename vector<T>::iterator > range )
{
// prints vector v with range delimited by [ and ]
for( typename vector<T>::const_iterator i = v.begin(); i != v.end(); ++i )
{
if( i == range.first )
{
cout << "[ ";
}
if( i == range.second )
{
cout << "] ";
}
cout << *i << " ";
}
cout << endl;
}
template<class T> void equal_range_demo( const vector<T>& original_vector, T val )
{
vector<T> v(original_vector);
sort( v.begin(), v.end() );
cout << "Vector sorted by the default binary predicate <:" << endl << '\t';
for( vector<T>::const_iterator i = v.begin(); i != v.end(); ++i )
{
cout << *i << " ";
}
cout << endl << endl;
pair< vector<T>::iterator, vector<T>::iterator > result
= equal_range( v.begin(), v.end(), val );
cout << "Result of equal_range with val = " << val << ":" << endl << '\t';
dump_vector( v, result );
cout << endl;
}
template<class T, class F> void equal_range_demo( const vector<T>& original_vector, T val, F pred, string predname )
{
vector<T> v(original_vector);
sort( v.begin(), v.end(), pred );
cout << "Vector sorted by the binary predicate " << predname << ":" << endl << '\t';
for( typename vector<T>::const_iterator i = v.begin(); i != v.end(); ++i )
{
cout << *i << " ";
}
cout << endl << endl;
pair< typename vector<T>::iterator, typename vector<T>::iterator > result
= equal_range( v.begin(), v.end(), val, pred );
cout << "Result of equal_range with val = " << val << ":" << endl << '\t';
dump_vector( v, result );
cout << endl;
}
// Return whether absolute value of elem1 is less than absolute value of elem2
bool abs_lesser( int elem1, int elem2 )
{
return abs(elem1) < abs(elem2);
}
// Return whether string l is shorter than string r
bool shorter_than(const string& l, const string& r)
{
return l.size() < r.size();
}
int main()
{
vector<int> v1;
// Constructing vector v1 with default less than ordering
for( int i = -1; i <= 4; ++i )
{
v1.push_back(i);
}
for( int i =-3; i <= 0; ++i )
{
v1.push_back( i );
}
equal_range_demo( v1, 3 );
equal_range_demo( v1, 3, greater<int>(), "greater" );
equal_range_demo( v1, 3, abs_lesser, "abs_lesser" );
vector<string> v2;
v2.push_back("cute");
v2.push_back("fluffy");
v2.push_back("kittens");
v2.push_back("fun");
v2.push_back("meowmeowmeow");
v2.push_back("blah");
equal_range_demo<string>( v2, "fred" );
equal_range_demo<string>( v2, "fred", shorter_than, "shorter_than" );
}
填滿
將相同的新值指派到指定範圍內的每個項目。
template<class ForwardIterator, class Type>
void fill(
ForwardIterator _First,
ForwardIterator _Last,
const Type& _Val);
參數
_First
正向迭代器定址範圍中的第一個項目的位置周遊。
_Last
正向迭代器定址超過一個位置的最終項目範圍中周遊。
_Val
要指派給範圍中的元素的值 [ _First， _Last)。
備註
目標範圍必須有效;所有指標都必須都可以取值，和最後一個位置是從第一個連線可透過遞增。 複雜性為線性範圍的大小。
範例
// alg_fill.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 9 ; i++ )
{
v1.push_back( 5 * i );
}
cout << "Vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// Fill the last 5 positions with a value of 2
fill( v1.begin( ) + 5, v1.end( ), 2 );
cout << "Modified v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
}
Vector v1 = ( 0 5 10 15 20 25 30 35 40 45 )
Modified v1 = ( 0 5 10 15 20 2 2 2 2 2 )
fill_n
將新值指派給指定的數字中的項目範圍開頭與特定的項目。
template<class OutputIterator, class Size, class Type>
OutputIterator fill_n(
OutputIterator First,
Size Count,
const Type& Val);
參數
First
輸出迭代器定址範圍中的第一個項目的位置的值指派給Val。
Count
帶正負號或不帶正負號的整數類型，指定的項目數，可指派值。
Val
要指派給範圍中的元素的值 [ First，第一個 + 計數)。
傳回值
若填入迭代器指向最後一個項目後面的項目Count> 零，否則為第一個項目。
備註
目標範圍必須有效;所有指標都必須都可以取值，和最後一個位置是從第一個連線可透過遞增。 複雜性為線性範圍的大小。
範例
// alg_fill_n.cpp
// compile using /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main()
{
using namespace std;
vector <int> v;
for ( auto i = 0 ; i < 9 ; ++i )
v.push_back( 0 );
cout << " vector v = ( " ;
for ( const auto &w : v )
cout << w << " ";
cout << ")" << endl;
// Fill the first 3 positions with a value of 1, saving position.
auto pos = fill_n( v.begin(), 3, 1 );
cout << "modified v = ( " ;
for ( const auto &w : v )
cout << w << " ";
cout << ")" << endl;
// Fill the next 3 positions with a value of 2, using last position.
fill_n( pos, 3, 2 );
cout << "modified v = ( " ;
for ( const auto &w : v )
cout << w << " ";
cout << ")" << endl;
// Fill the last 3 positions with a value of 3, using relative math.
fill_n( v.end()-3, 3, 3 );
cout << "modified v = ( " ;
for ( const auto &w : v )
cout << w << " ";
cout << ")" << endl;
}
尋找
在範圍中找出有指定值的第一個項目的位置。
template<class InputIterator, class T>
InputIterator find(
InputIterator first,
InputIterator last,
const T& val);
參數
first
輸入迭代器，其定址要搜尋指定值的範圍中，第一個元素的位置。
last
輸入迭代器，其定址要搜尋指定值的範圍中，最後一個元素後方的位置。
val
要搜尋的值。
傳回值
輸入迭代器，其定址所搜尋的範圍中第一次出現的指定值。 如果找不到具有相等值的任何元素，會傳回 last。
備註
operator== 用來決定元素及指定值間的比對，是否必須施加其運算元之間的等價關聯。
程式碼範例使用find()，請參閱find_if。
find_end
在範圍中尋找與指定序列相同 (或在二元述詞指定的意義上，相當於該序列) 的最後一個子序列。
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end(
ForwardIterator1 First1,
ForwardIterator1 Last1,
ForwardIterator2 First2,
ForwardIterator2 Last2);
template<class ForwardIterator1, class ForwardIterator2, class Pred>
ForwardIterator1 find_end(
ForwardIterator1 First1,
ForwardIterator1 Last1,
ForwardIterator2 First2,
ForwardIterator2 Last2,
Pred Comp);
參數
First1
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
Last1
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
First2
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
Last2
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器會定址符合指定序列 [First2, Last2) 的 [First1, Last1) 中最後一個子序列的第一個元素的位置。
備註
operator== 用來決定元素及指定值間的比對，是否必須施加其運算元之間的等價關聯。
參考的範圍必須有效；所有指標都必須可以取值，而且在每個序列中，可透過遞增從第一個位置到達最後一個位置。
範例
// alg_find_end.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
// Return whether second element is twice the first
bool twice ( int elem1, int elem2 )
{
return 2 * elem1 == elem2;
}
int main( )
{
using namespace std;
vector <int> v1, v2;
list <int> L1;
vector <int>::iterator Iter1, Iter2;
list <int>::iterator L1_Iter, L1_inIter;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
int ii;
for ( ii = 1 ; ii <= 4 ; ii++ )
{
L1.push_back( 5 * ii );
}
int iii;
for ( iii = 2 ; iii <= 4 ; iii++ )
{
v2.push_back( 10 * iii );
}
cout << "Vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
cout << "List L1 = ( " ;
for ( L1_Iter = L1.begin( ) ; L1_Iter!= L1.end( ) ; L1_Iter++ )
cout << *L1_Iter << " ";
cout << ")" << endl;
cout << "Vector v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// Searching v1 for a match to L1 under identity
vector <int>::iterator result1;
result1 = find_end ( v1.begin( ), v1.end( ), L1.begin( ), L1.end( ) );
if ( result1 == v1.end( ) )
cout << "There is no match of L1 in v1."
<< endl;
else
cout << "There is a match of L1 in v1 that begins at "
<< "position "<< result1 - v1.begin( ) << "." << endl;
// Searching v1 for a match to L1 under the binary predicate twice
vector <int>::iterator result2;
result2 = find_end ( v1.begin( ), v1.end( ), v2.begin( ), v2.end( ), twice );
if ( result2 == v1.end( ) )
cout << "There is no match of L1 in v1."
<< endl;
else
cout << "There is a sequence of elements in v1 that "
<< "are equivalent to those\n in v2 under the binary "
<< "predicate twice and that begins at position "
<< result2 - v1.begin( ) << "." << endl;
}
Vector v1 = ( 0 5 10 15 20 25 0 5 10 15 20 25 )
List L1 = ( 5 10 15 20 )
Vector v2 = ( 20 30 40 )
There is a match of L1 in v1 that begins at position 7.
There is a sequence of elements in v1 that are equivalent to those
in v2 under the binary predicate twice and that begins at position 8.
find_first_of
在目標範圍內搜尋第一次出現的任何多個值，或第一次出現的任何多個項目 (在二元述詞指定的意義上，相當於指定之項目集合)。
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_first_of(
ForwardIterator1 _First1,
ForwardIterator1 Last1,
ForwardIterator2 _First2,
ForwardIterator2 Last2);
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 find_first_of(
ForwardIterator1 _First1,
ForwardIterator1 Last1,
ForwardIterator2 _First2,
ForwardIterator2 Last2,
BinaryPredicate _Comp);
參數
_First1
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
_Last1
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
_First2
正向迭代器，其定址要比對範圍中第一個元素的位置。
_Last2
正向迭代器，其定址要比對範圍中最後一個元素之後的位置。
_Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器會定址符合指定序列，或等於二元述詞所指定之意義的第一個子序列的第一個元素的位置。
備註
operator== 用來決定元素及指定值間的比對，是否必須施加其運算元之間的等價關聯。
參考的範圍必須有效；所有指標都必須可以取值，而且在每個序列中，可透過遞增從第一個位置到達最後一個位置。
範例
// alg_find_first_of.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
// Return whether second element is twice the first
bool twice ( int elem1, int elem2 )
{
return 2 * elem1 == elem2;
}
int main( )
{
using namespace std;
vector <int> v1, v2;
list <int> L1;
vector <int>::iterator Iter1, Iter2;
list <int>::iterator L1_Iter, L1_inIter;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
int ii;
for ( ii = 3 ; ii <= 4 ; ii++ )
{
L1.push_back( 5 * ii );
}
int iii;
for ( iii = 2 ; iii <= 4 ; iii++ )
{
v2.push_back( 10 * iii );
}
cout << "Vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
cout << "List L1 = ( " ;
for ( L1_Iter = L1.begin( ) ; L1_Iter!= L1.end( ) ; L1_Iter++ )
cout << *L1_Iter << " ";
cout << ")" << endl;
cout << "Vector v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// Searching v1 for first match to L1 under identity
vector <int>::iterator result1;
result1 = find_first_of ( v1.begin( ), v1.end( ), L1.begin( ), L1.end( ) );
if ( result1 == v1.end( ) )
cout << "There is no match of L1 in v1."
<< endl;
else
cout << "There is at least one match of L1 in v1"
<< "\n and the first one begins at "
<< "position "<< result1 - v1.begin( ) << "." << endl;
// Searching v1 for a match to L1 under the binary predicate twice
vector <int>::iterator result2;
result2 = find_first_of ( v1.begin( ), v1.end( ), v2.begin( ), v2.end( ), twice );
if ( result2 == v1.end( ) )
cout << "There is no match of L1 in v1."
<< endl;
else
cout << "There is a sequence of elements in v1 that "
<< "are equivalent\n to those in v2 under the binary "
<< "predicate twice\n and the first one begins at position "
<< result2 - v1.begin( ) << "." << endl;
}
Vector v1 = ( 0 5 10 15 20 25 0 5 10 15 20 25 )
List L1 = ( 15 20 )
Vector v2 = ( 20 30 40 )
There is at least one match of L1 in v1
and the first one begins at position 3.
There is a sequence of elements in v1 that are equivalent
to those in v2 under the binary predicate twice
and the first one begins at position 2.
find_if
在範圍中找出滿足特定條件的第一個項目的位置。
template<class InputIterator, class Predicate>
InputIterator find_if(
InputIterator first,
InputIterator last,
Predicate pred);
參數
first
輸入迭代器，其定址要搜尋範圍中第一個元素的位置。
last
輸入迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
pred
使用者定義的述詞函式物件或lambda 運算式，定義要搜尋的項目所要符合的條件。 述詞會接受單一引數，並傳回 true (符合) 或 false (不符合)。 pred 的簽章必須有效地 bool pred(const T& arg);，其中 T 是取值時可隱含轉換 InputIterator 的類型。 const 關鍵字顯示只是為了說明，所以函式物件或 Lambda 不應修改引數。
傳回值
輸入迭代器，指出與述詞所指定的條件 (述詞產生的 true) 相符的範圍中的第一個元素。 如果沒有發現任何符合述詞的元素，會傳回 last。
備註
這個範本函式是演算法的一般化尋找，取代述詞 「 等於特定值 」 任意述詞。 如邏輯相反 （尋找不符合述詞的第一個元素），請參閱find_if_not。
範例
// cl.exe /W4 /nologo /EHsc /MTd
#include <vector>
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
template <typename S> void print(const S& s) {
for (const auto& p : s) {
cout << "(" << p << ") ";
}
cout << endl;
}
// Test std::find()
template <class InputIterator, class T>
void find_print_result(InputIterator first, InputIterator last, const T& value) {
// call <algorithm> std::find()
auto p = find(first, last, value);
cout << "value " << value;
if (p == last) {
cout << " not found." << endl;
} else {
cout << " found." << endl;
}
}
// Test std::find_if()
template <class InputIterator, class Predicate>
void find_if_print_result(InputIterator first, InputIterator last,
Predicate Pred, const string& Str) {
// call <algorithm> std::find_if()
auto p = find_if(first, last, Pred);
if (p == last) {
cout << Str << " not found." << endl;
} else {
cout << "first " << Str << " found: " << *p << endl;
}
}
// Function to use as the UnaryPredicate argument to find_if() in this example
bool is_odd_int(int i) {
return ((i % 2) != 0);
}
int main()
{
// Test using a plain old array.
const int x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
cout << "array x[] contents: ";
print(x);
// Using non-member std::begin()/std::end() to get input iterators for the plain old array.
cout << "Test std::find() with array..." << endl;
find_print_result(begin(x), end(x), 10);
find_print_result(begin(x), end(x), 42);
cout << "Test std::find_if() with array..." << endl;
find_if_print_result(begin(x), end(x), is_odd_int, "odd integer"); // function name
find_if_print_result(begin(x), end(x), // lambda
[](int i){ return ((i % 2) == 0); }, "even integer");
// Test using a vector.
vector<int> v;
for (int i = 0; i < 10; ++i) {
v.push_back((i + 1) * 10);
}
cout << endl << "vector v contents: ";
print(v);
cout << "Test std::find() with vector..." << endl;
find_print_result(v.begin(), v.end(), 20);
find_print_result(v.begin(), v.end(), 12);
cout << "Test std::find_if() with vector..." << endl;
find_if_print_result(v.begin(), v.end(), is_odd_int, "odd integer");
find_if_print_result(v.begin(), v.end(), // lambda
[](int i){ return ((i % 2) == 0); }, "even integer");
}
find_if_not
傳回指定範圍中不滿足條件的第一個項目。
template<class InputIterator, class Predicate>
InputIterator find_if_not(
InputIterator first,
InputIterator last,
Predicate pred);
參數
first
輸入迭代器，其定址要搜尋範圍中第一個元素的位置。
last
輸入迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
pred
使用者定義的述詞函式物件或lambda 運算式，定義要搜尋的項目不應符合的條件。 述詞會接受單一引數，並傳回 true (符合) 或 false (不符合)。 pred 的簽章必須有效地 bool pred(const T& arg);，其中 T 是取值時可隱含轉換 InputIterator 的類型。 const 關鍵字顯示只是為了說明，所以函式物件或 Lambda 不應修改引數。
傳回值
輸入迭代器，指出與述詞所指定的條件 (述詞產生的 false) 不符的範圍中的第一個元素。 如果所有元素符合述詞 (每個元素的 true 中的述詞結果)，會傳回 last。
備註
這個範本函式是演算法的一般化尋找，取代述詞 「 等於特定值 」 任意述詞。 如邏輯相反 （尋找符合述詞的第一個元素），請參閱find_if。
程式碼範例快速適用於find_if_not()，請參閱find_if。
for_each
將指定的函式物件以正向順序套用至範圍內的每個項目，並傳回函式物件。
template<class InputIterator, class Function>
Function for_each(
InputIterator _First,
InputIterator _Last,
Function _Func);
參數
_First
輸入迭代器定址要操作的範圍中第一個項目的位置。
_Last
輸入迭代器定址超過一個位置的最終項目範圍中操作。
_Func
套用至每個項目範圍中的使用者定義函式物件。
傳回值
套用至所有範圍中的項目之後的函式物件的複本。
備註
此演算法for_each是非常有彈性，讓每個項目的範圍內修改不同、 使用者定義的方式。 樣板化函式可能會在修改後的表單中重複使用藉由傳遞不同的參數。 使用者定義函式可能會累積在演算法可能會在處理所有範圍中的項目之後，傳回內部狀態的資訊。
參考的範圍必須有效；所有指標必須是可取值且在序列中，還必須要可以從第一個位置開始透過增量而取得最後一個位置。
複雜性為線性與最多 ( _Last – _First) 比較。
範例
// alg_for_each.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
// The function object multiplies an element by a Factor
template <class Type>
class MultValue
{
private:
Type Factor; // The value to multiply by
public:
// Constructor initializes the value to multiply by
MultValue ( const Type& _Val ) : Factor ( _Val ) {
}
// The function call for the element to be multiplied
void operator ( ) ( Type& elem ) const
{
elem *= Factor;
}
};
// The function object to determine the average
class Average
{
private:
long num; // The number of elements
long sum; // The sum of the elements
public:
// Constructor initializes the value to multiply by
Average ( ) : num ( 0 ) , sum ( 0 )
{
}
// The function call to process the next elment
void operator ( ) ( int elem ) \
{
num++; // Increment the element count
sum += elem; // Add the value to the partial sum
}
// return Average
operator double ( )
{
return static_cast <double> (sum) /
static_cast <double> (num);
}
};
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
// Constructing vector v1
int i;
for ( i = -4 ; i <= 2 ; i++ )
{
v1.push_back( i );
}
cout << "Original vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Using for_each to multiply each element by a Factor
for_each ( v1.begin ( ) , v1.end ( ) , MultValue<int> ( -2 ) );
cout << "Multiplying the elements of the vector v1\n "
<< "by the factor -2 gives:\n v1mod1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// The function object is templatized and so can be
// used again on the elements with a different Factor
for_each (v1.begin ( ) , v1.end ( ) , MultValue<int> (5 ) );
cout << "Multiplying the elements of the vector v1mod\n "
<< "by the factor 5 gives:\n v1mod2 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// The local state of a function object can accumulate
// information about a sequence of actions that the
// return value can make available, here the Average
double avemod2 = for_each ( v1.begin ( ) , v1.end ( ) ,
Average ( ) );
cout << "The average of the elements of v1 is:\n Average ( v1mod2 ) = "
<< avemod2 << "." << endl;
}
Original vector v1 = ( -4 -3 -2 -1 0 1 2 ).
Multiplying the elements of the vector v1
by the factor -2 gives:
v1mod1 = ( 8 6 4 2 0 -2 -4 ).
Multiplying the elements of the vector v1mod
by the factor 5 gives:
v1mod2 = ( 40 30 20 10 0 -10 -20 ).
The average of the elements of v1 is:
Average ( v1mod2 ) = 10.
產生
將函式物件產生的值指派給範圍內的每個項目。
template<class ForwardIterator, class Generator>
void generate(
ForwardIterator _First,
ForwardIteratorLast,
Generator _Gen);
參數
_First
正向迭代器定址的值為指派的範圍中的第一個項目位置。
_Last
第一個位置定址過去的值是要指派的範圍中最後一個項目正向迭代器。
_Gen
不搭配引數呼叫的函式物件，用於產生要指派到範圍中每個項目的值。
備註
會為範圍中的每個項目叫用函式物件，且不需要在每次呼叫時傳回相同的值。 例如，其可能會從檔案讀取，或是參考及修改本機狀態。 產生器的結果類型必須是可以轉換為轉送至此範圍之迭代器的值類型。
參考的範圍必須有效；所有指標必須是可取值且在序列中，還必須要可以從第一個位置開始透過增量而取得最後一個位置。
就是線性具有複雜度 ( _Last – _First) 產生器所需的呼叫。
範例
// alg_generate.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
#include <ostream>
int main( )
{
using namespace std;
// Assigning random values to vector integer elements
vector <int> v1 ( 5 );
vector <int>::iterator Iter1;
deque <int> deq1 ( 5 );
deque <int>::iterator d1_Iter;
generate ( v1.begin ( ), v1.end ( ) , rand );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Assigning random values to deque integer elements
generate ( deq1.begin ( ), deq1.end ( ) , rand );
cout << "Deque deq1 is ( " ;
for ( d1_Iter = deq1.begin( ) ; d1_Iter != deq1.end( ) ; d1_Iter++ )
cout << *d1_Iter << " ";
cout << ")." << endl;
}
Vector v1 is ( 41 18467 6334 26500 19169 ).
Deque deq1 is ( 15724 11478 29358 26962 24464 ).
generate_n
將函式物件產生的值指派給範圍內的指定項目數，並返回到超過最後一個指定值的位置。
template<class OutputIterator, class Diff, class Generator>
void generate_n(
OutputIterator First,
Diff Count,
Generator Gen);
參數
First
輸出迭代器，指向範圍中第一個項目的位置 (要指派值至其中)。
Count
帶正負號或不帶正負號的整數類型，指定要由產生器函式指派值的項目數。
Gen
不搭配引數呼叫的函式物件，用於產生要指派到範圍中每個項目的值。
備註
會為範圍中的每個項目叫用函式物件，且不需要在每次呼叫時傳回相同的值。 例如，其可能會從檔案讀取，或是參考及修改本機狀態。 產生器的結果類型必須是可以轉換為轉送至此範圍之迭代器的值類型。
參考的範圍必須有效；所有指標必須是可取值且在序列中，還必須要可以從第一個位置開始透過增量而取得最後一個位置。
線性具有複雜度，因此需要對產生器執行明確的 Count 呼叫。
範例
// cl.exe /EHsc /nologo /W4 /MTd
#include <vector>
#include <deque>
#include <iostream>
#include <string>
#include <algorithm>
#include <random>
using namespace std;
template <typename C> void print(const string& s, const C& c) {
cout << s;
for (const auto& e : c) {
cout << e << " ";
}
cout << endl;
}
int main()
{
const int elemcount = 5;
vector<int> v(elemcount);
deque<int> dq(elemcount);
// Set up random number distribution
random_device rd;
mt19937 engine(rd());
uniform_int_distribution<int> dist(-9, 9);
// Call generate_n, using a lambda for the third parameter
generate_n(v.begin(), elemcount, [&](){ return dist(engine); });
print("vector v is: ", v);
generate_n(dq.begin(), elemcount, [&](){ return dist(engine); });
print("deque dq is: ", dq);
}
包含
測試一個排序範圍是否包含第二個排序範圍內的所有項目，其中項目之間的順序或等價準則可由二元述詞指定。
template<class InputIterator1, class InputIterator2>
bool includes(
InputIterator1 _First1,
InputIterator1 _Last1,
InputIterator2 _First2,
InputIterator2 _Last2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool includes(
InputIterator1 _First1,
InputIterator1 _Last1,
InputIterator2 _First2,
InputIterator2 _Last2,
BinaryPredicate _Comp );
參數
_First1
輸入迭代器定址的第一個項目中兩個排序的來源範圍的第一個要測試的第二個的所有項目是否包含在第一個位置。
_Last1
輸入迭代器定址超過一個位置的最後一個項目第一次的兩個排序的來源範圍的第二個的所有項目是否包含在第一個測試。
_First2
輸入迭代器定址的第一個元素的位置中的兩個第二個連續排序來源範圍的第二個的所有項目是否包含在第一個測試。
_Last2
輸入迭代器定址一個之後的最後一個元素的位置中的兩個連續排序的來源範圍的第二個，要測試的第二個的所有項目是否包含在第一個。
_Comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
true如果第一個排序的範圍中包含所有項目，第二個排序範圍; 否則false。
備註
將這項測試的另一個方法是它取決於第二個來源範圍是否為第一個來源範圍的子集。
參考的排序的來源範圍必須有效;所有指標都必須都可以取值，且在每個序列，最後一個位置必須都要可以從第一個可透過遞增。
排序的來源範圍必須每個排列演算法的應用程式的先決條件包括根據相同的排序方式為，是使用演算法來排序合併的範圍。
演算法 merge不會修改來源範圍。
輸入迭代器的實值類型必須是小於比較才能建立此順序：因此若提供了兩個元素，可以判斷它們相等 (任一個都不小於另一個的意義)，或者一個小於另一個。 這會導致非對等元件之間的排序。 更精確地說，演算法會測試是否指定二元述詞下第一個排序範圍內的所有元素都有對等順序的第二個排序範圍內。
演算法的複雜性為線性最多 2 * (( _Last1 – _First1) – ( _Last2 – _First2)) – 1 非空白的來源範圍的比較。
範例
// alg_includes.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1a, v1b;
vector <int>::iterator Iter1a, Iter1b;
// Constructing vectors v1a & v1b with default less-than ordering
int i;
for ( i = -2 ; i <= 4 ; i++ )
{
v1a.push_back( i );
}
int ii;
for ( ii =-2 ; ii <= 3 ; ii++ )
{
v1b.push_back( ii );
}
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vectors v2a & v2b with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b );
vector <int>::iterator Iter2a, Iter2b;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
v2a.pop_back ( );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vectors v3a & v3b with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) ;
vector <int>::iterator Iter3a, Iter3b;
reverse (v3a.begin( ), v3a.end( ) );
v3a.pop_back ( );
v3a.pop_back ( );
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To test for inclusion under an asscending order
// with the default binary predicate less <int> ( )
bool Result1;
Result1 = includes ( v1a.begin ( ) , v1a.end ( ) ,
v1b.begin ( ) , v1b.end ( ) );
if ( Result1 )
cout << "All the elements in vector v1b are "
<< "contained in vector v1a." << endl;
else
cout << "At least one of the elements in vector v1b "
<< "is not contained in vector v1a." << endl;
// To test for inclusion under descending
// order specify binary predicate greater<int>( )
bool Result2;
Result2 = includes ( v2a.begin ( ) , v2a.end ( ) ,
v2b.begin ( ) , v2b.end ( ) , greater <int> ( ) );
if ( Result2 )
cout << "All the elements in vector v2b are "
<< "contained in vector v2a." << endl;
else
cout << "At least one of the elements in vector v2b "
<< "is not contained in vector v2a." << endl;
// To test for inclusion under a user
// defined binary predicate mod_lesser
bool Result3;
Result3 = includes ( v3a.begin ( ) , v3a.end ( ) ,
v3b.begin ( ) , v3b.end ( ) , mod_lesser );
if ( Result3 )
cout << "All the elements in vector v3b are "
<< "contained under mod_lesser in vector v3a."
<< endl;
else
cout << "At least one of the elements in vector v3b is "
<< " not contained under mod_lesser in vector v3a."
<< endl;
}
Original vector v1a with range sorted by the
binary predicate less than is v1a = ( -2 -1 0 1 2 3 4 ).
Original vector v1b with range sorted by the
binary predicate less than is v1b = ( -2 -1 0 1 2 3 ).
Original vector v2a with range sorted by the
binary predicate greater is v2a = ( 4 3 2 1 0 -1 ).
Original vector v2b with range sorted by the
binary predicate greater is v2b = ( 3 2 1 0 -1 -2 ).
Original vector v3a with range sorted by the
binary predicate mod_lesser is v3a = ( 0 1 2 3 4 ).
Original vector v3b with range sorted by the
binary predicate mod_lesser is v3b = ( 0 -1 1 -2 2 3 ).
All the elements in vector v1b are contained in vector v1a.
At least one of the elements in vector v2b is not contained in vector v2a.
At least one of the elements in vector v3b is not contained under mod_lesser in vector v3a.
inplace_merge
將兩個連續排序範圍內的項目結合成單一排序範圍，其中順序準則可由二元述詞指定。
template<class BidirectionalIterator>
void inplace_merge(
BidirectionalIterator _First,
BidirectionalIterator _Middle,
BidirectionalIterator _Last);
template<class BidirectionalIterator, class Predicate>
void inplace_merge(
BidirectionalIterator _First,
BidirectionalIterator _Middle,
BidirectionalIterator _Last,
Predicate _Comp);
參數
_First
雙向迭代器定址的第一個元素的位置，在兩個連續的第一個排序範圍結合及排序成單一範圍。
_Middle
雙向迭代器定址的第一個項目位置的兩個連續的第二個排序範圍結合及排序成單一範圍。
_Last
雙向迭代器定址超過最後一個元素的第一個位置的兩個連續的第二個排序範圍結合及排序成單一範圍。
_Comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
備註
參考的已排序的連續範圍必須有效;所有指標都必須都可以取值，且在每個序列，最後一個位置必須都要可以從第一個可透過遞增。
已排序的連續範圍必須每個排列應用程式的前提inplace_merge根據相同的排序方式為演算法會使用演算法來排序合併的範圍。 作業是穩定的因為會保留每個範圍內之項目的相對順序。 當兩個來源範圍中有對等項目時，此元素是第一個範圍合併的範圍會位於第二個項目。
複雜度取決於可用的記憶體，演算法會配置的暫存緩衝區的記憶體。 足夠的記憶體是否可用，最好的情況下是以線性 ( _Last – _First) – 1 比較; 如果沒有輔助記憶體可用，則最糟的情況是N記錄*(N)，其中N* = ( _Last – _First)。
範例
// alg_inplace_merge.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> //For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1, Iter2, Iter3;
// Constructing vector v1 with default less-than ordering
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii =-5 ; ii <= 0 ; ii++ )
{
v1.push_back( ii );
}
cout << "Original vector v1 with subranges sorted by the\n "
<< "binary predicate less than is v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// Constructing vector v2 with ranges sorted by greater
vector <int> v2 ( v1 );
vector <int>::iterator break2;
break2 = find ( v2.begin ( ) , v2.end ( ) , -5 );
sort ( v2.begin ( ) , break2 , greater<int> ( ) );
sort ( break2 , v2.end ( ) , greater<int> ( ) );
cout << "Original vector v2 with subranges sorted by the\n "
<< "binary predicate greater is v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// Constructing vector v3 with ranges sorted by mod_lesser
vector <int> v3 ( v1 );
vector <int>::iterator break3;
break3 = find ( v3.begin ( ) , v3.end ( ) , -5 );
sort ( v3.begin ( ) , break3 , mod_lesser );
sort ( break3 , v3.end ( ) , mod_lesser );
cout << "Original vector v3 with subranges sorted by the\n "
<< "binary predicate mod_lesser is v3 = ( " ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")" << endl;
vector <int>::iterator break1;
break1 = find (v1.begin ( ) , v1.end ( ) , -5 );
inplace_merge ( v1.begin( ), break1, v1.end( ) );
cout << "Merged inplace with default order,\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To merge inplace in descending order, specify binary
// predicate greater<int>( )
inplace_merge ( v2.begin( ), break2 , v2.end( ) , greater<int>( ) );
cout << "Merged inplace with binary predicate greater specified,\n "
<< "vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// Applying a user defined (UD) binary predicate mod_lesser
inplace_merge ( v3.begin( ), break3, v3.end( ), mod_lesser );
cout << "Merged inplace with binary predicate mod_lesser specified,\n "
<< "vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")" << endl;
}
Original vector v1 with subranges sorted by the
binary predicate less than is v1 = ( 0 1 2 3 4 5 -5 -4 -3 -2 -1 0 )
Original vector v2 with subranges sorted by the
binary predicate greater is v2 = ( 5 4 3 2 1 0 0 -1 -2 -3 -4 -5 )
Original vector v3 with subranges sorted by the
binary predicate mod_lesser is v3 = ( 0 1 2 3 4 5 0 -1 -2 -3 -4 -5 )
Merged inplace with default order,
vector v1mod = ( -5 -4 -3 -2 -1 0 0 1 2 3 4 5 )
Merged inplace with binary predicate greater specified,
vector v2mod = ( 5 4 3 2 1 0 0 -1 -2 -3 -4 -5 )
Merged inplace with binary predicate mod_lesser specified,
vector v3mod = ( 0 0 1 -1 2 -2 3 -3 4 -4 5 -5 )
is_heap
如果在指定範圍內的項目形成堆積，則傳回 true。
template<class RandomAccessIterator>
bool is_heap(
RandomAccessIterator _First,
RandomAccessIterator _Last);
template<class RandomAccessIterator, class BinaryPredicate>
bool is_heap(
RandomAccessIterator _First,
RandomAccessIterator _Last,
BinaryPredicate _Comp);
參數
_First
隨機存取迭代器，表示要檢查堆積的範圍開頭。
_Last
隨機存取迭代器，指出範圍的結尾。
_Comp
條件，來測試訂單項目。 二元述詞會採用單一引數並傳回true或false。
傳回值
傳回true如果指定的範圍內的項目形成堆積，false如果不相符。
備註
第一個樣板函式傳回is_heap_until (``_First``, _Last``) == _Last。
第二個樣板函式傳回
is_heap_until ( _First , _Last , _Comp ) == _Last.
is_heap_until
傳回位於範圍中的第一個元素的迭代器 [ begin， end) 中不符合堆積排序條件，或end如果範圍形成堆積。
template<class RandomAccessIterator>
RandomAccessIterator is_heap_until(
RandomAccessIterator begin,
RandomAccessIterator end);
template<class RandomAccessIterator, class BinaryPredicate>
RandomAccessIterator is_heap_until(
RandomAccessIterator begin,
RandomAccessIterator end,
BinaryPredicate compare);
參數
begin
隨機存取迭代器，指定要檢查有無堆積之範圍的第一個項目。
end
隨機存取迭代器，指定要檢查有無堆積的範圍結尾。
compare
二元述詞，指定定義堆積的嚴格弱式排序條件。 未指定 compare 時的預設述詞為 std::less<>。
傳回值
如果指定的範圍形成堆積，或包含一個或更少的項目，則傳回 end。 否則會傳回所找到第一個不符合堆積條件之項目的迭代器。
備註
第一個樣板函式傳回的最後一個迭代器next中[``begin``,``end``]其中[``begin``, next)是函式物件所排序的堆積std::less<>。 如果距離end - begin < 2，此函數會傳回end。
第二個樣板函式的行為與第一個樣板函式相同，但會使用述詞 compare (而不是 std::less<>) 做為堆積排序條件。
is_partitioned
如果在指定範圍內針對條件測試為 true 的所有項目都是在測試為 true 的任何項目之前，傳回 false。
template<class InputIterator, class BinaryPredicate>
bool is_partitioned(
InputIterator _First,
InputIterator _Last,
BinaryPredicate _Comp);
參數
_First
輸入迭代器，表示要檢查符合條件範圍的開始位置。
_Last
輸入迭代器，指出範圍的結尾。
_Comp
若要測試的條件。 這被提供使用者定義的述詞函式物件，定義要搜尋的項目所要符合的條件。 述詞會採用單一引數並傳回true或false。
傳回值
則傳回 true 時所有指定的範圍中的項目true的條件來測試任何項目之前false，否則會傳回與false。
備註
樣板函式傳回true才中的所有項目[``_First``,``_Last``)由進行分割_Comp; 也就是說，所有的項目X中[``_First``,``_Last``)的_Comp``(X)是為 true，則會發生在所有項目之前Y的_Comp``(Y)是false。
is_permutation
如果兩個範圍包含相同的項目，則不論項目的順序是否相同，都會傳回 true。 使用 C++14 程式碼中的雙重範圍多載，因為如果第二個範圍超過第一個範圍，只為第二個範圍採用單一迭代器的多載不會偵測到差異；而如果第二個範圍比第一個範圍短，則會導致未定義的行為。
template<class ForwardIterator1, class ForwardIterator2>
bool is_permutation(
ForwardIterator1 First1,
ForwardIterator1 Last1,
ForwardIterator2 First2);
template<class ForwardIterator1, class ForwardIterator2, class Predicate>
bool is_permutation(
ForwardIterator1 First1,
ForwardIterator1 Last1,
ForwardIterator2 First2,
Predicate Pred);
// C++14
template<class ForwardIterator1, class ForwardIterator2>
bool is_permutation(
ForwardIterator1 First1,
ForwardIterator1 Last1,
ForwardIterator2 First2,
ForwardIterator2 Last2);
template<class ForwardIterator1, class ForwardIterator2, class Predicate>
bool is_permutation(
ForwardIterator1 First1,
ForwardIterator1 Last1,
ForwardIterator2 First2,
ForwardIterator2 Last2,
Predicate Pred);
參數
First1
指向範圍的第一個項目的正向迭代器。
Last1
指向範圍的最後項目前一個的正向迭代器。
First2
指向第二個範圍的第一個項目的正向迭代器，用於比較。
Last2
指向第二個範圍的最後一個項目之某個項目的正向迭代器，用於比較。
Pred
述詞，用於測試是否相等並傳回 bool。
傳回值
可根據比較子述詞，將範圍重新排列成完全相同時，則為 true，否則為 false。
備註
is_permutation 在最壞的情況有二次方的複雜性。
第一個樣板函式假設處開始的範圍中有多的項目First2中指定的範圍有 [ First1， Last1)。 如果第二個範圍中有多個項目，就會忽略它們；如果更少，就會發生未定義的行為。 第三個樣板函式 (C++ 14 和更新版本) 不會進行這項假設。 這兩者都會傳回true才，針對指定的範圍中每個項目 X [ First1， Last1) X 的相同範圍中有多的項目 Y = = Y 處開始的範圍中有First2或 [ First2, Last2). ，operator==必須執行的成對比較其運算元之間。
第二個和第四個樣板函式的行為相同，不同之處是它們會以 Pred(X, Y) 取代 operator==(X, Y)。 若要正常運作，述詞必須對稱、自反和轉移。
範例
下列範例顯示如何使用 is_permutation：
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
vector<int> vec_1{ 2, 3, 0, 1, 4, 5 };
vector<int> vec_2{ 5, 4, 0, 3, 1, 2 };
vector<int> vec_3{ 4, 9, 13, 3, 6, 5 };
vector<int> vec_4{ 7, 4, 11, 9, 2, 1 };
cout << "(1) Compare using built-in == operator: ";
cout << boolalpha << is_permutation(vec_1.begin(), vec_1.end(),
vec_2.begin(), vec_2.end()) << endl; // true
cout << "(2) Compare after modifying vec_2: ";
vec_2[0] = 6;
cout << is_permutation(vec_1.begin(), vec_1.end(),
vec_2.begin(), vec_2.end()) << endl; // false
// Define equivalence as "both are odd or both are even"
cout << "(3) vec_3 is a permutation of vec_4: ";
cout << is_permutation(vec_3.begin(), vec_3.end(),
vec_4.begin(), vec_4.end(),
[](int lhs, int rhs) { return lhs % 2 == rhs % 2; }) << endl; // true
// Initialize a vector using the 's' string literal to specify a std::string
vector<string> animals_1{ "dog"s, "cat"s, "bird"s, "monkey"s };
vector<string> animals_2{ "donkey"s, "bird"s, "meerkat"s, "cat"s };
// Define equivalence as "first letters are equal":
bool is_perm = is_permutation(animals_1.begin(), animals_1.end(), animals_2.begin(), animals_2.end(),
[](const string& lhs, const string& rhs)
{
return lhs[0] == rhs[0]; //std::string guaranteed to have at least a null terminator
});
cout << "animals_2 is a permutation of animals_1: " << is_perm << endl; // true
cout << "Press a letter" << endl;
char c;
cin >> c;
return 0;
}
is_sorted
如果在指定範圍內的項目為已排序順序，則傳回 true。
template<class ForwardIterator>
bool is_sorted(
ForwardIterator _First,
ForwardIterator _Last);
template<class ForwardIterator, class BinaryPredicate>
bool is_sorted(
ForwardIterator _First,
ForwardIterator _Last,
BinaryPredicate _Comp);
參數
_First
正向迭代器，表示要檢查之範圍的開始處。
_Last
正向迭代器，表示某個範圍的結束。
_Comp
要測試，以判斷兩個項目之間的順序的條件。 述詞會採用單一引數並傳回true或false。 這會執行相同的工作operator<。
備註
第一個樣板函式傳回is_sorted_until (``_First``, _Last``) == _Last。 運算子< function performs the order comparison. function="" performs="" the="" order=""></ function performs the order comparison.>
第二個樣板函式傳回is_sorted_until``(``_First``, _Last``, _Comp``) == _Last。 _Comp述詞函式執行順序比較。
is_sorted_until
傳回ForwardIterator設定的最後一個項目是依排序順序，從指定的範圍。
第二個版本可讓您提供BinaryPredicate函式會傳回true排序的順序，兩個指定的項目時，false否則。
template<class ForwardIterator>
ForwardIterator is_sorted_until(
ForwardIterator _First,
ForwardIterator _Last
);
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator is_sorted_until(
ForwardIterator _First,
ForwardIterator _Last,
BinaryPredicate _Comp
);
參數
_First
正向迭代器，表示要檢查之範圍的開始位置。
_Last
正向迭代器，表示某個範圍的結束。
_Comp
要測試，以判斷兩個項目之間的順序的條件。 述詞會採用單一引數並傳回true或false。
傳回值
傳回ForwardIterator排序順序中設定的最後一個項目。 排序的順序會從_First。
備註
第一個樣板函式傳回的最後一個迭代器next中[``_First``,``_Last``]以便[``_First``, next)排序的順序排序的operator<。 如果distance()``< 2函式會傳回_Last。
第二個樣板函式的行為相同，不同之處在於它會取代operator<(X, Y)與_Comp``(X, Y)。
iter_swap
交換由一組指定之迭代器所參考的兩個值。
template<class ForwardIterator1, class ForwardIterator2>
void iter_swap( ForwardIterator1 _Left, ForwardIterator2 _Right );
參數
_Left
其中一個值會交換的正向迭代器。
_Right
第二個值會交換的正向迭代器。
備註
swap應該優先使用我ter_swap，這包含在 c + + 標準為回溯相容性。 If Fit1 and Fit2 are forward iterators, then iter_swap ( Fit1, Fit2 ), is equivalent to swap ( * Fit1, * Fit2 ).
輸入正向迭代器的實值型別必須有相同的值。
範例
// alg_iter_swap.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt
{
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) { m_nVal =
rhs.m_nVal; return *this; }
bool operator<( const CInt& rhs ) const
{ return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<( ostream& osIn, const CInt& rhs );
private:
int m_nVal;
};
inline ostream& operator<<( ostream& osIn, const CInt& rhs )
{
osIn << "CInt(" << rhs.m_nVal << ")";
return osIn;
}
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
};
int main( )
{
CInt c1 = 5, c2 = 1, c3 = 10;
deque<CInt> deq1;
deque<CInt>::iterator d1_Iter;
deq1.push_back ( c1 );
deq1.push_back ( c2 );
deq1.push_back ( c3 );
cout << "The original deque of CInts is deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl;
// Exchanging first and last elements with iter_swap
iter_swap ( deq1.begin ( ) , --deq1.end ( ) );
cout << "The deque of CInts with first & last elements swapped is:\n deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl;
// Swapping back first and last elements with swap
swap ( *deq1.begin ( ) , *(deq1.end ( ) -1 ) );
cout << "The deque of CInts with first & last elements swapped back is:\n deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl;
// Swapping a vector element with a deque element
vector <int> v1;
vector <int>::iterator Iter1;
deque <int> deq2;
deque <int>::iterator d2_Iter;
int i;
for ( i = 0 ; i <= 3 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii = 4 ; ii <= 5 ; ii++ )
{
deq2.push_back( ii );
}
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Deque deq2 is ( " ;
for ( d2_Iter = deq2.begin( ) ; d2_Iter != deq2.end( ) ; d2_Iter++ )
cout << *d2_Iter << " ";
cout << ")." << endl;
iter_swap ( v1.begin ( ) , deq2.begin ( ) );
cout << "After exchanging first elements,\n vector v1 is: v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl << " & deque deq2 is: deq2 = ( ";
for ( d2_Iter = deq2.begin( ) ; d2_Iter != deq2.end( ) ; d2_Iter++ )
cout << *d2_Iter << " ";
cout << ")." << endl;
}
The original deque of CInts is deq1 = ( CInt
(5), CInt
(1), CInt
(10) ).
The deque of CInts with first & last elements swapped is:
deq1 = ( CInt
(10), CInt
(1), CInt
(5) ).
The deque of CInts with first & last elements swapped back is:
deq1 = ( CInt
(5), CInt
(1), CInt
(10) ).
Vector v1 is ( 0 1 2 3 ).
Deque deq2 is ( 4 5 ).
After exchanging first elements,
vector v1 is: v1 = ( 4 1 2 3 ).
& deque deq2 is: deq2 = ( 0 5 ).
lexicographical_compare
逐一比較兩個序列之間的每個項目，判斷兩者較小者。
template<class InputIterator1, class InputIterator2>
bool lexicographical_compare(
InputIterator1 _First1,
InputIterator1 Last1,
InputIterator2 _First2,
InputIterator2 Last2 );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool lexicographical_compare(
InputIterator1 _First1,
InputIterator1 Last1,
InputIterator2 _First2,
InputIterator2 Last2,
BinaryPredicate _Comp );
參數
_First1
輸入迭代器定址的第一個項目中的第一個範圍的位置進行比較。
_Last1
輸入迭代器定址的第一個範圍中的最後一個項目超過其中一個位置進行比較。
_First2
輸入迭代器定址第二個範圍中的第一個項目的位置進行比較。
_Last2
輸入迭代器定址第二個範圍中的最後一個項目超過其中一個位置進行比較。
_Comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
true如果第一個範圍是字數小於第二個的範圍; 否則false。
備註
序列進行語彙比較比較它們的項目之前︰
找到兩個對應的項目不相等，並比較其結果會被視為序列之間比較的結果。
找不到任何式，但一個序列有多個項目，而較短的序列會被視為比小於較長的順序。
找不到任何不等式序列具有相同數目的項目，並因此序列相等和比較的結果為 false。
範例
// alg_lex_comp.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
// Return whether second element is twice the first
bool twice ( int elem1, int elem2 )
{
return 2 * elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1, v2;
list <int> L1;
vector <int>::iterator Iter1, Iter2;
list <int>::iterator L1_Iter, L1_inIter;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
int ii;
for ( ii = 0 ; ii <= 6 ; ii++ )
{
L1.push_back( 5 * ii );
}
int iii;
for ( iii = 0 ; iii <= 5 ; iii++ )
{
v2.push_back( 10 * iii );
}
cout << "Vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
cout << "List L1 = ( " ;
for ( L1_Iter = L1.begin( ) ; L1_Iter!= L1.end( ) ; L1_Iter++ )
cout << *L1_Iter << " ";
cout << ")" << endl;
cout << "Vector v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// Self lexicographical_comparison of v1 under identity
bool result1;
result1 = lexicographical_compare (v1.begin( ), v1.end( ),
v1.begin( ), v1.end( ) );
if ( result1 )
cout << "Vector v1 is lexicographically_less than v1." << endl;
else
cout << "Vector v1 is not lexicographically_less than v1." << endl;
// lexicographical_comparison of v1 and L2 under identity
bool result2;
result2 = lexicographical_compare (v1.begin( ), v1.end( ),
L1.begin( ), L1.end( ) );
if ( result2 )
cout << "Vector v1 is lexicographically_less than L1." << endl;
else
cout << "Vector v1 is lexicographically_less than L1." << endl;
bool result3;
result3 = lexicographical_compare (v1.begin( ), v1.end( ),
v2.begin( ), v2.end( ), twice );
if ( result3 )
cout << "Vector v1 is lexicographically_less than v2 "
<< "under twice." << endl;
else
cout << "Vector v1 is not lexicographically_less than v2 "
<< "under twice." << endl;
}
Vector v1 = ( 0 5 10 15 20 25 )
List L1 = ( 0 5 10 15 20 25 30 )
Vector v2 = ( 0 10 20 30 40 50 )
Vector v1 is not lexicographically_less than v1.
Vector v1 is lexicographically_less than L1.
Vector v1 is not lexicographically_less than v2 under twice.
lower_bound
在已排序範圍中尋找值大於或相當於指定值的第一個項目的位置，其中順序準則可由二元述詞指定。
template<class ForwardIterator, class Type>
ForwardIterator lower_bound(
ForwardIterator first,
ForwardIterator last,
const Type& value );
template<class ForwardIterator, class Type, class BinaryPredicate>
ForwardIterator lower_bound(
ForwardIterator first,
ForwardIterator last,
const Type& value,
BinaryPredicate comp );
參數
first
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
last
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
value
值，其第一個位置或可能的第一個位置要搜尋的已排序的範圍內。
comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器位置的第一個項目大於或等於指定的值，其值與排序範圍中由二元述詞指定相同的位置。
備註
參考的排序的來源範圍必須有效;所有迭代器必須可以取值，而且在序列中最後一個位置必須可從第一個可透過遞增。
已排序的範圍是使用的前置條件lower_bound和其中的順序是二元述詞所指定的值相同。
範圍不會修改演算法lower_bound。
正向迭代器的實值型別必須是小於-比比較排序，以便提供兩個項目，可以判斷它們相等 （中都不小於另的意義） 或是其中一個是小於另。 這會導致非對等元件之間的排序
演算法的複雜度是對數隨機存取迭代器和線性比例的步驟數目與否則 ( last – first)。
範例
// alg_lower_bound.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector<int> v1;
// Constructing vector v1 with default less-than ordering
for ( auto i = -1 ; i <= 4 ; ++i )
{
v1.push_back( i );
}
for ( auto ii =-3 ; ii <= 0 ; ++ii )
{
v1.push_back( ii );
}
cout << "Starting vector v1 = ( " ;
for (const auto &Iter : v1)
cout << Iter << " ";
cout << ")." << endl;
sort(v1.begin(), v1.end());
cout << "Original vector v1 with range sorted by the\n "
<< "binary predicate less than is v1 = ( " ;
for (const auto &Iter : v1)
cout << Iter << " ";
cout << ")." << endl;
// Constructing vector v2 with range sorted by greater
vector<int> v2(v1);
sort(v2.begin(), v2.end(), greater<int>());
cout << "Original vector v2 with range sorted by the\n "
<< "binary predicate greater is v2 = ( " ;
for (const auto &Iter : v2)
cout << Iter << " ";
cout << ")." << endl;
// Constructing vectors v3 with range sorted by mod_lesser
vector<int> v3(v1);
sort(v3.begin(), v3.end(), mod_lesser);
cout << "Original vector v3 with range sorted by the\n "
<< "binary predicate mod_lesser is v3 = ( " ;
for (const auto &Iter : v3)
cout << Iter << " ";
cout << ")." << endl;
// Demonstrate lower_bound
vector<int>::iterator Result;
// lower_bound of 3 in v1 with default binary predicate less<int>()
Result = lower_bound(v1.begin(), v1.end(), 3);
cout << "The lower_bound in v1 for the element with a value of 3 is: "
<< *Result << "." << endl;
// lower_bound of 3 in v2 with the binary predicate greater<int>( )
Result = lower_bound(v2.begin(), v2.end(), 3, greater<int>());
cout << "The lower_bound in v2 for the element with a value of 3 is: "
<< *Result << "." << endl;
// lower_bound of 3 in v3 with the binary predicate mod_lesser
Result = lower_bound(v3.begin(), v3.end(), 3, mod_lesser);
cout << "The lower_bound in v3 for the element with a value of 3 is: "
<< *Result << "." << endl;
}
make_heap
將在指定範圍內的項目轉換為堆積，其中第一個項目是最大，而且排序準則可由二元述詞指定。
template<class RandomAccessIterator>
void make_heap(
RandomAccessIterator _First,
RandomAccessIteratorLast );
template<class RandomAccessIterator, class BinaryPredicate>
void make_heap(
RandomAccessIterator _First,
RandomAccessIteratorLast,
BinaryPredicate _Comp );
參數
_First
隨機存取迭代器定址要轉換成堆積範圍中的第一個項目的位置。
_Last
隨機存取迭代器定址超過要轉換成堆積的範圍中最後一個項目的其中一個位置。
_Comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
堆積具有兩個屬性︰
第一個項目一定是最大。
可以加入或移除對數時間項目。
堆積是理想的方式實作優先順序佇列，以及使用標準樣板程式庫容器配接器的實作中priority_queue 類別。
複雜性為線性需要 3 * ( _Last – _First) 比較。
範例
// alg_make_heap.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
int main() {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
random_shuffle( v1.begin( ), v1.end( ) );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Make v1 a heap with default less than ordering
make_heap ( v1.begin( ), v1.end( ) );
cout << "The heaped version of vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Make v1 a heap with greater than ordering
make_heap ( v1.begin( ), v1.end( ), greater<int>( ) );
cout << "The greater-than heaped version of v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
最大值
比較兩個物件並傳回兩者較大者，其中順序準則可由二元述詞指定。
template<class Type>
const Type& max(
const Type& _Left,
const Type& _Right
);
template<class Type, class Pr>
const Type& max(
const Type& _Left,
const Type& _Right,
BinaryPredicate _Comp
);
template<class Type>
Type& max (
initializer_list<Type> _Ilist
);
template<class Type, class Pr>
Type& max(
initializer_list<Type> _Ilist,
BinaryPredicate _Comp
);
參數
_Left
正在比較的兩個物件之第一個。
_Right
正在比較的兩個物件之第二個。
_Comp
用來比較兩個物件的二元述詞。
_IList
包含要比較的物件之初始設定式清單。
傳回值
兩個物件中較大的一個，除非兩者一樣大，在此情況下，它會傳回兩個物件的第一個。 在使用 initializer_list 的情況下，它會傳回此清單中最大的物件。
備註
max 是不尋常的演算法，因為它將物件做為參數傳遞。 大部分的標準範本程式庫演算法可在項目的範圍上運作，其位置由迭代器做為參數傳遞來加以指定。 如果您需要的項目範圍運作的函式，使用max_element改。
範例
// alg_max.cpp
// compile with: /EHsc
#include <vector>
#include <set>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt
{
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) {m_nVal =
rhs.m_nVal; return *this;}
bool operator<( const CInt& rhs ) const
{return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<( ostream& osIn, const CInt& rhs );
private:
int m_nVal;
};
inline ostream& operator<<( ostream& osIn, const CInt& rhs )
{
osIn << "CInt( " << rhs.m_nVal << " )";
return osIn;
}
// Return whether absolute value of elem1 is greater than
// absolute value of elem2
bool abs_greater ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = -elem1;
if ( elem2 < 0 )
elem2 = -elem2;
return elem1 < elem2;
};
int main( )
{
int a = 6, b = -7;
// Return the integer with the larger absolute value
const int& result1 = max(a, b, abs_greater);
// Return the larger integer
const int& result2 = max(a, b);
cout << "Using integers 6 and -7..." << endl;
cout << "The integer with the greater absolute value is: "
<< result1 << "." << endl;
cout << "The integer with the greater value is: "
<< result2 << "." << endl;
cout << endl;
// Comparing the members of an initializer_list
const int& result3 = max({ a, b });
const int& result4 = max({ a, b }, abs_greater);
cout << "Comparing the members of an initializer_list..." << endl;
cout << "The member with the greater value is: " << result3 << endl;
cout << "The integer with the greater absolute value is: " << result4 << endl;
// Comparing set containers with elements of type CInt
// using the max algorithm
CInt c1 = 1, c2 = 2, c3 = 3;
set<CInt> s1, s2, s3;
set<CInt>::iterator s1_Iter, s2_Iter, s3_Iter;
s1.insert ( c1 );
s1.insert ( c2 );
s2.insert ( c2 );
s2.insert ( c3 );
cout << "s1 = (";
for ( s1_Iter = s1.begin( ); s1_Iter != --s1.end( ); s1_Iter++ )
cout << " " << *s1_Iter << ",";
s1_Iter = --s1.end( );
cout << " " << *s1_Iter << " )." << endl;
cout << "s2 = (";
for ( s2_Iter = s2.begin( ); s2_Iter != --s2.end( ); s2_Iter++ )
cout << " " << *s2_Iter << ",";
s2_Iter = --s2.end( );
cout << " " << *s2_Iter << " )." << endl;
s3 = max ( s1, s2 );
cout << "s3 = max ( s1, s2 ) = (";
for ( s3_Iter = s3.begin( ); s3_Iter != --s3.end( ); s3_Iter++ )
cout << " " << *s3_Iter << ",";
s3_Iter = --s3.end( );
cout << " " << *s3_Iter << " )." << endl << endl;
// Comparing vectors with integer elements using the max algorithm
vector <int> v1, v2, v3, v4, v5;
vector <int>::iterator Iter1, Iter2, Iter3, Iter4, Iter5;
int i;
for ( i = 0 ; i <= 2 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii = 0 ; ii <= 2 ; ii++ )
{
v2.push_back( ii );
}
int iii;
for ( iii = 0 ; iii <= 2 ; iii++ )
{
v3.push_back( 2 * iii );
}
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Vector v2 is ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
cout << "Vector v3 is ( " ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
v4 = max ( v1, v2 );
v5 = max ( v1, v3 );
cout << "Vector v4 = max (v1,v2) is ( " ;
for ( Iter4 = v4.begin( ) ; Iter4 != v4.end( ) ; Iter4++ )
cout << *Iter4 << " ";
cout << ")." << endl;
cout << "Vector v5 = max (v1,v3) is ( " ;
for ( Iter5 = v5.begin( ) ; Iter5 != v5.end( ) ; Iter5++ )
cout << *Iter5 << " ";
cout << ")." << endl;
}
Using integers 6 and -7...
The integer with the greater absolute value is: -7
The integer with the greater value is: 6.
Comparing the members of an initializer_list...The member with the greater value is: 6The integer wiht the greater absolute value is: -7
s1 = ( CInt( 1 ), CInt( 2 ) ).
s2 = ( CInt( 2 ), CInt( 3 ) ).
s3 = max ( s1, s2 ) = ( CInt( 2 ), CInt( 3 ) ).
Vector v1 is ( 0 1 2 ).
Vector v2 is ( 0 1 2 ).
Vector v3 is ( 0 2 4 ).
Vector v4 = max (v1,v2) is ( 0 1 2 ).
Vector v5 = max (v1,v3) is ( 0 2 4 ).
max_element
在指定的範圍內尋找第一個最大項目，其中順序準則可由二元述詞指定。
template<class ForwardIterator>
ForwardIterator max_element(ForwardIterator _First, ForwardIteratorLast );
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator max_element(ForwardIterator _First, ForwardIteratorLast, BinaryPredicate _Comp );
參數
_First
正向迭代器範圍中的第一個項目的位置定址要搜尋的最大的項目。
_Last
正向迭代器定址超過範圍中最後一個項目的其中一個位置要搜尋的最大的項目。
_Comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
正向迭代器範圍中的第一個最大項目位置搜尋。
備註
參考的範圍必須有效;所有指標都必須都可以取值，而且在每個序列的最後一個位置可以從第可透過遞增。
複雜性為線性: ( _Last – _First) – 1 比較所需的非空白的範圍。
範例
// alg_max_element.cpp
// compile with: /EHsc
#include <vector>
#include <set>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt
{
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) {m_nVal =
rhs.m_nVal; return *this;}
bool operator<( const CInt& rhs ) const
{return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<( ostream& osIn, const CInt& rhs );
private:
int m_nVal;
};
inline ostream& operator<<(ostream& osIn, const CInt& rhs)
{
osIn << "CInt( " << rhs.m_nVal << " )";
return osIn;
}
// Return whether modulus of elem1 is greater than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
};
int main( )
{
// Searching a set container with elements of type CInt
// for the maximum element
CInt c1 = 1, c2 = 2, c3 = -3;
set<CInt> s1;
set<CInt>::iterator s1_Iter, s1_R1_Iter, s1_R2_Iter;
s1.insert ( c1 );
s1.insert ( c2 );
s1.insert ( c3 );
cout << "s1 = (";
for ( s1_Iter = s1.begin( ); s1_Iter != --s1.end( ); s1_Iter++ )
cout << " " << *s1_Iter << ",";
s1_Iter = --s1.end( );
cout << " " << *s1_Iter << " )." << endl;
s1_R1_Iter = max_element ( s1.begin ( ) , s1.end ( ) );
cout << "The largest element in s1 is: " << *s1_R1_Iter << endl;
cout << endl;
// Searching a vector with elements of type int for the maximum
// element under default less than & mod_lesser binary predicates
vector <int> v1;
vector <int>::iterator v1_Iter, v1_R1_Iter, v1_R2_Iter;
int i;
for ( i = 0 ; i <= 3 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii = 1 ; ii <= 4 ; ii++ )
{
v1.push_back( - 2 * ii );
}
cout << "Vector v1 is ( " ;
for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
cout << *v1_Iter << " ";
cout << ")." << endl;
v1_R1_Iter = max_element ( v1.begin ( ) , v1.end ( ) );
v1_R2_Iter = max_element ( v1.begin ( ) , v1.end ( ), mod_lesser);
cout << "The largest element in v1 is: " << *v1_R1_Iter << endl;
cout << "The largest element in v1 under the mod_lesser"
<< "\n binary predicate is: " << *v1_R2_Iter << endl;
}
合併
將兩個排序來源範圍內的所有項目結合成單一排序目的範圍，其中順序準則可由二元述詞指定。
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
OutputIterator merge(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result,
BinaryPredicate _Comp );
參數
_First1
輸入迭代器，用於定址要結合並排序成單一範圍之兩個排序來源範圍的第一個範圍中，第一個項目的位置。
_Last1
輸入迭代器，用於定址要結合並排序成單一範圍之兩個排序來源範圍的第一個範圍中，最後一個項目的後面一個位置。
_First2
輸入迭代器，用於定址要結合並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，第一個項目的位置。
_Last2
輸入迭代器，用於定址要結合並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，最後一個項目的後面一個位置。
_Result
輸出迭代器，用於定址目的範圍中第一個項目的位置，在此目的範圍中，兩個來源範圍會結合成單一排序範圍。
_Comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
輸出迭代器，用於定址排序目的範圍中最後一個項目的後面一個位置。
備註
參考的排序來源範圍必須有效；所有指標都必須可以取值，而且在每個序列中，必須可透過遞增從第一個位置到達最後一個位置。
目的範圍與任何一個來源範圍都不應該重疊，而且大小應該足以包含目的範圍。
每個排序來源範圍必須根據 merge 演算法用來排序結合範圍的相同順序，排列成套用此演算法的前置條件。
這項作業很穩定，因為每個範圍內的元素相對順序會保留在目的範圍中。 演算法 merge不會修改來源範圍。
輸入迭代器的實值類型必須是小於比較才能建立此順序：因此若提供了兩個元素，可以判斷它們相等 (任一個都不小於另一個的意義)，或者一個小於另一個。 這會導致非對等元件之間的排序。 當兩個來源範圍中有對等元素時，目的範圍之第一個來源範圍中的元素會優先於第二個範圍中的元素。
演算法的複雜性為線性與最多 ( _Last1 – _First1) – ( _Last2 – _First2) – 1 的比較。
List 類別提供成員函式，「 合併 」 來合併兩個清單項目。
範例
// alg_merge.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 ) {
if (elem1 < 0)
elem1 = - elem1;
if (elem2 < 0)
elem2 = - elem2;
return elem1 < elem2;
}
int main() {
using namespace std;
vector <int> v1a, v1b, v1 ( 12 );
vector <int>::iterator Iter1a, Iter1b, Iter1;
// Constructing vector v1a and v1b with default less than ordering
int i;
for ( i = 0 ; i <= 5 ; i++ )
v1a.push_back( i );
int ii;
for ( ii =-5 ; ii <= 0 ; ii++ )
v1b.push_back( ii );
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vector v2 with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
vector <int>::iterator Iter2a, Iter2b, Iter2;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vector v3 with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) , v3 ( v1 );
vector <int>::iterator Iter3a, Iter3b, Iter3;
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To merge inplace in ascending order with default binary
// predicate less <int> ( )
merge ( v1a.begin ( ) , v1a.end ( ) , v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
cout << "Merged inplace with default order,\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To merge inplace in descending order, specify binary
// predicate greater<int>( )
merge ( v2a.begin ( ) , v2a.end ( ) , v2b.begin ( ) , v2b.end ( ) ,
v2.begin ( ) , greater <int> ( ) );
cout << "Merged inplace with binary predicate greater specified,\n "
<< "vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// Applying A user-defined (UD) binary predicate mod_lesser
merge ( v3a.begin ( ) , v3a.end ( ) , v3b.begin ( ) , v3b.end ( ) ,
v3.begin ( ) , mod_lesser );
cout << "Merged inplace with binary predicate mod_lesser specified,\n "
<< "vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
最小值
比較兩個物件並傳回兩者較小者，其中順序準則可由二元述詞指定。
template<class Type>
const Type& min(
const Type& _Left,
const Type& _Right
);
template<class Type, class Pr>
const Type& min(
const Type& _Left,
const Type& _Right,
BinaryPredicate _Comp
);
template<class Type>
Type min ( initializer_list<Type> _Ilist
);
template<class Type, class Pr> Type min (
initializer_list<Type> _Ilist,
BinaryPredicate _Comp
);
參數
_Left
正在比較的兩個物件之第一個。
_Right
正在比較的兩個物件之第二個。
_Comp
用來比較兩個物件的二元述詞。
_IList
Initializer_list，包含要比較的成員。
傳回值
較小的兩個物件，除非都較小者。在此情況下，它會傳回兩個物件的第一個。 在 initializer_list，它會傳回最少的物件清單中。
備註
min 是不尋常的演算法，因為它將物件做為參數傳遞。 大部分的標準範本程式庫演算法可在項目的範圍上運作，其位置由迭代器做為參數傳遞來加以指定。 如果您需要使用的項目範圍的函式，使用min_element。
範例
// alg_min.cpp
// compile with: /EHsc
#include <vector>
#include <set>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt
{
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) {m_nVal =
rhs.m_nVal; return *this;}
bool operator<( const CInt& rhs ) const
{return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<(ostream& osIn, const CInt& rhs);
private:
int m_nVal;
};
inline ostream& operator<<( ostream& osIn, const CInt& rhs )
{
osIn << "CInt( " << rhs.m_nVal << " )";
return osIn;
}
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
};
int main( )
{
// Comparing integers directly using the min algorithm with
// binary predicate mod_lesser & with default less than
int a = 6, b = -7, c = 7 ;
const int& result1 = min ( a, b, mod_lesser );
const int& result2 = min ( b, c );
cout << "The mod_lesser of the integers 6 & -7 is: "
<< result1 << "." << endl;
cout << "The lesser of the integers -7 & 7 is: "
<< result2 << "." << endl;
cout << endl;
// Comparing the members of an initializer_list
const int& result3 = min({ a, c });
const int& result4 = min({ a, b }, mod_lesser);
cout << "The lesser of the integers 6 & 7 is: "
<< result3 << "." << endl;
cout << "The mod_lesser of the integers 6 & -7 is: "
<< result4 << "." << endl;
cout << endl;
// Comparing set containers with elements of type CInt
// using the min algorithm
CInt c1 = 1, c2 = 2, c3 = 3;
set<CInt> s1, s2, s3;
set<CInt>::iterator s1_Iter, s2_Iter, s3_Iter;
s1.insert ( c1 );
s1.insert ( c2 );
s2.insert ( c2 );
s2.insert ( c3 );
cout << "s1 = (";
for ( s1_Iter = s1.begin( ); s1_Iter != --s1.end( ); s1_Iter++ )
cout << " " << *s1_Iter << ",";
s1_Iter = --s1.end( );
cout << " " << *s1_Iter << " )." << endl;
cout << "s2 = (";
for ( s2_Iter = s2.begin( ); s2_Iter != --s2.end( ); s2_Iter++ )
cout << " " << *s2_Iter << ",";
s2_Iter = --s2.end( );
cout << " " << *s2_Iter << " )." << endl;
s3 = min ( s1, s2 );
cout << "s3 = min ( s1, s2 ) = (";
for ( s3_Iter = s3.begin( ); s3_Iter != --s3.end( ); s3_Iter++ )
cout << " " << *s3_Iter << ",";
s3_Iter = --s3.end( );
cout << " " << *s3_Iter << " )." << endl << endl;
// Comparing vectors with integer elements using min algorithm
vector <int> v1, v2, v3, v4, v5;
vector <int>::iterator Iter1, Iter2, Iter3, Iter4, Iter5;
int i;
for ( i = 0 ; i <= 2 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii = 0 ; ii <= 2 ; ii++ )
{
v2.push_back( ii );
}
int iii;
for ( iii = 0 ; iii <= 2 ; iii++ )
{
v3.push_back( 2 * iii );
}
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Vector v2 is ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
cout << "Vector v3 is ( " ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
v4 = min ( v1, v2 );
v5 = min ( v1, v3 );
cout << "Vector v4 = min ( v1,v2 ) is ( " ;
for ( Iter4 = v4.begin( ) ; Iter4 != v4.end( ) ; Iter4++ )
cout << *Iter4 << " ";
cout << ")." << endl;
cout << "Vector v5 = min ( v1,v3 ) is ( " ;
for ( Iter5 = v5.begin( ) ; Iter5 != v5.end( ) ; Iter5++ )
cout << *Iter5 << " ";
cout << ")." << endl;
}
The mod_lesser of the integers 6 & -7 is: 6.
The lesser of the integers -7 & 7 is: -7.
The lesser of the integers 6 & 7 is: 6.The mod_lesser of the integers 6 & -7 is: 6.
s1 = ( CInt
( 1 ), CInt
( 2 ) ).
s2 = ( CInt
( 2 ), CInt
( 3 ) ).
s3 = min ( s1, s2 ) = ( CInt
( 1 ), CInt
( 2 ) ).
Vector v1 is ( 0 1 2 ).
Vector v2 is ( 0 1 2 ).
Vector v3 is ( 0 2 4 ).
Vector v4 = min ( v1,v2 ) is ( 0 1 2 ).
Vector v5 = min ( v1,v3 ) is ( 0 1 2 ).
min_element
在指定的範圍內尋找第一個最小項目，其中順序準則可由二元述詞指定。
template<class ForwardIterator>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last );
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
參數
first
正向迭代器範圍中的第一個項目的位置定址要搜尋的最小元素。
last
正向迭代器定址超過範圍中最後一個項目的其中一個位置要搜尋的最小元素。
comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
正向迭代器範圍中的第一個最小項目位置搜尋。
備註
參考的範圍必須有效;所有指標都必須都可以取值，而且在每個序列的最後一個位置可以從第可透過遞增。
複雜性為線性: ( last – first) – 1 比較所需的非空白的範圍。
範例
// alg_min_element.cpp
// compile with: /EHsc
#include <vector>
#include <set>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt
{
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) {m_nVal =
rhs.m_nVal; return *this;}
bool operator<( const CInt& rhs ) const
{return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<( ostream& osIn, const CInt& rhs );
private:
int m_nVal;
};
inline ostream& operator<<( ostream& osIn, const CInt& rhs )
{
osIn << "CInt( " << rhs.m_nVal << " )";
return osIn;
}
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
};
int main()
{
// Searching a set container with elements of type CInt
// for the minimum element
CInt c1 = 1, c2 = 2, c3 = -3;
set<CInt> s1;
set<CInt>::iterator s1_Iter, s1_R1_Iter, s1_R2_Iter;
s1.insert ( c1 );
s1.insert ( c2 );
s1.insert ( c3 );
cout << "s1 = (";
for ( s1_Iter = s1.begin( ); s1_Iter != --s1.end( ); s1_Iter++ )
cout << " " << *s1_Iter << ",";
s1_Iter = --s1.end( );
cout << " " << *s1_Iter << " )." << endl;
s1_R1_Iter = min_element ( s1.begin ( ) , s1.end ( ) );
cout << "The smallest element in s1 is: " << *s1_R1_Iter << endl;
cout << endl;
// Searching a vector with elements of type int for the maximum
// element under default less than & mod_lesser binary predicates
vector <int> v1;
vector <int>::iterator v1_Iter, v1_R1_Iter, v1_R2_Iter;
int i;
for ( i = 0 ; i <= 3 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii = 1 ; ii <= 4 ; ii++ )
{
v1.push_back( - 2 * ii );
}
cout << "Vector v1 is ( " ;
for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
cout << *v1_Iter << " ";
cout << ")." << endl;
v1_R1_Iter = min_element ( v1.begin ( ) , v1.end ( ) );
v1_R2_Iter = min_element ( v1.begin ( ) , v1.end ( ), mod_lesser);
cout << "The smallest element in v1 is: " << *v1_R1_Iter << endl;
cout << "The smallest element in v1 under the mod_lesser"
<< "\n binary predicate is: " << *v1_R2_Iter << endl;
}
s1 = ( CInt
( -3 ), CInt
( 1 ), CInt
( 2 ) ).
The smallest element in s1 is: CInt
( -3 )
Vector v1 is ( 0 1 2 3 -2 -4 -6 -8 ).
The smallest element in v1 is: -8
The smallest element in v1 under the mod_lesser
binary predicate is: 0
minmax_element
執行所執行的工作min_element和max_element一次呼叫中。
template<class ForwardIterator>
pair< ForwardIterator, ForwardIterator >
minmax_element(
ForwardIterator _First,
ForwardIterator Last
);
template<class ForwardIterator, class BinaryPredicate>
pair< ForwardIterator, ForwardIterator >
minmax_element(
ForwardIterator _First,
ForwardIterator Last,
BinaryPredicate _Comp
);
參數
_First
正向迭代器表示範圍的開頭。
_Last
正向迭代器，表示某個範圍的結束。
_Comp
選擇性的測試，用來訂單項目。
傳回值
Returns
pair<ForwardIterator, ForwardIterator>
(min_element( _First, _Last), max_element( _First, _Last)).
備註
第一個樣板函式傳回
pair<ForwardIterator,ForwardIterator>
(min_element(_First,Last),max_element(_First,Last)).
第二個樣板函式的行為相同，不同之處在於它會取代operator<(X, Y)與_Comp``(X, Y)。
如果序列是空白，函式在執行最多3 * (``_Last - _First - 1) / 2比較。
minmax
比較兩個輸入的參數並傳回做為順序的一組，以更高的較小者。
template<class Type>
pair<const Type&, const Type&>
minmax(
const Type& _Left,
const Type& _Right
);
template<class Type, class BinaryPredicate>
pair<const Type&, const Type&>
minmax(
const Type& _Left,
const Type& _Right,
BinaryPredicate _Comp
);
template<class Type> pair<Type&, Type&> minmax(
initializer_list<Type> _Ilist
);
template<class Type, class BinaryPredicate>
pair<Type&, Type&> minmax(
initializer_list<Type> _Ilist,
BinaryPredicate _Comp
);
參數
_Left
正在比較的兩個物件之第一個。
_Right
正在比較的兩個物件之第二個。
_Comp
用來比較兩個物件的二元述詞。
_IList
Initializer_list，包含要比較的成員。
備註
第一個樣板函式傳回pair<const Type&, const Type&>(``_Right``,``_Left``)如果_Right是小於_Left。 否則，它會傳回pair<const Type&, const Type&>(``_Left``, _Right``)。
第二個成員函式傳回一組，其中第一個項目是較小者，而第二個是較大的述詞所比較時_Comp。
其餘的範本函式的行為相同，不同之處在於它們取代_Left和_Right參數_IList。
函式會執行一個比較。
不相符
逐一比較兩個範圍的每個項目，找出差異發生的第一個位置。
使用 C++14 程式碼中的雙重範圍多載，因為如果第二個範圍超過第一個範圍，只為第二個範圍採用單一迭代器的多載不會偵測到差異；而如果第二個範圍比第一個範圍短，則會導致未定義的行為。
template<class InputIterator1, class InputIterator2> pair<InputIterator1, InputIterator2>>
mismatch(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2 );
template<class InputIterator1, class InputIterator2, class BinaryPredicate> pair<InputIterator1, InputIterator2>>
mismatch(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2,
BinaryPredicate Comp );
//C++14
template<class InputIterator1, class InputIterator2> pair<InputIterator1, InputIterator2>>
mismatch(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2,
InputIterator2 Last2 );
template<class InputIterator1, class InputIterator2, class BinaryPredicate> pair<InputIterator1, InputIterator2>>
mismatch(
InputIterator1 First1,
InputIterator1 Last1,
InputIterator2 First2,
InputIterator2 Last2,
BinaryPredicate Comp);
參數
First1
輸入迭代器，定址要測試的第一個範圍中第一個項目的位置。
Last1
輸入迭代器，定址要測試的第一個範圍中最後一個項目的後面一個位置。
First2
輸入迭代器，定址要測試的第二個範圍中第一個項目的位置。
Last2
輸入迭代器，定址要測試的第二個範圍中最後一個項目的後面一個位置。
Comp
使用者定義述詞函式物件，比較每個範圍中的目前項目，並判斷是否相等。 它會傳回true符合時則和false不符合時。
傳回值
一組迭代器，定址兩個範圍中不相符的位置，第一個元件迭代器指向第一個範圍中的位置，而第二個元件迭代器指向第二個範圍中的位置。 如果比較的範圍中的項目之間沒有差異，或第二個版本中的二元述詞由兩個範圍的所有項目配對所滿足，則第一個元件迭代器會指向第一個範圍中最後一個項目的後面一個位置，而第二個元件迭代器會指向第二個範圍中測試的最後一個項目的後面一個位置。
備註
第一個樣板函式會假設範圍中從 first2 開始的項目數，與 [first1, last1) 指定的範圍中的項目數相同。 如果第二個範圍中的項目較多，則會忽略它們；如果較少，則會導致未定義的行為。
要搜尋的範圍必須有效；所有迭代器都必須可以取值，而且可透過遞增從第一個位置到達最後一個位置。
在較短範圍內包含的項目數中，演算法的時間複雜性呈線性。
使用者定義的述詞不需要在運算元之間強加對稱、自反和遞移的等價關係。
範例
下列範例示範如何使用不相符。 顯示 C++03 多載只是為了示範可能產生非預期的結果。
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
using namespace std;
// Return whether first element is twice the second
// Note that this is not a symmetric, reflexive and transitive equivalence.
// mismatch and equal accept such predicates, but is_permutation does not.
bool twice(int elem1, int elem2)
{
return elem1 == elem2 * 2;
}
void PrintResult(const string& msg, const pair<vector<int>::iterator, vector<int>::iterator>& result,
const vector<int>& left, const vector<int>& right)
{
// If either iterator stops before reaching the end of its container,
// it means a mismatch was detected.
if (result.first != left.end() || result.second != right.end())
{
string leftpos(result.first == left.end() ? "end" : to_string(*result.first));
string rightpos(result.second == right.end() ? "end" : to_string(*result.second));
cout << msg << "mismatch. Left iterator at " << leftpos
<< " right iterator at " << rightpos << endl;
}
else
{
cout << msg << " match." << endl;
}
}
int main()
{
vector<int> vec_1{ 0, 5, 10, 15, 20, 25 };
vector<int> vec_2{ 0, 5, 10, 15, 20, 25, 30 };
// Testing different length vectors for mismatch (C++03)
auto match_vecs = mismatch(vec_1.begin(), vec_1.end(), vec_2.begin());
bool is_mismatch = match_vecs.first != vec_1.end();
cout << "C++03: vec_1 and vec_2 are a mismatch: " << boolalpha << is_mismatch << endl;
// Using dual-range overloads:
// Testing different length vectors for mismatch (C++14)
match_vecs = mismatch(vec_1.begin(), vec_1.end(), vec_2.begin(), vec_2.end());
PrintResult("C++14: vec_1 and vec_2: ", match_vecs, vec_1, vec_2);
// Identify point of mismatch between vec_1 and modified vec_2.
vec_2[3] = 42;
match_vecs = mismatch(vec_1.begin(), vec_1.end(), vec_2.begin(), vec_2.end());
PrintResult("C++14 vec_1 v. vec_2 modified: ", match_vecs, vec_1, vec_2);
// Test vec_3 and vec_4 for mismatch under the binary predicate twice (C++14)
vector<int> vec_3{ 10, 20, 30, 40, 50, 60 };
vector<int> vec_4{ 5, 10, 15, 20, 25, 30 };
match_vecs = mismatch(vec_3.begin(), vec_3.end(), vec_4.begin(), vec_4.end(), twice);
PrintResult("vec_3 v. vec_4 with pred: ", match_vecs, vec_3, vec_4);
vec_4[5] = 31;
match_vecs = mismatch(vec_3.begin(), vec_3.end(), vec_4.begin(), vec_4.end(), twice);
PrintResult("vec_3 v. modified vec_4 with pred: ", match_vecs, vec_3, vec_4);
// Compare a vector<int> to a list<int>
list<int> list_1{ 0, 5, 10, 15, 20, 25 };
auto match_vec_list = mismatch(vec_1.begin(), vec_1.end(), list_1.begin(), list_1.end());
is_mismatch = match_vec_list.first != vec_1.end() || match_vec_list.second != list_1.end();
cout << "vec_1 and list_1 are a mismatch: " << boolalpha << is_mismatch << endl;
char c;
cout << "Press a key" << endl;
cin >> c;
}
/*
Output:
C++03: vec_1 and vec_2 are a mismatch: false
C++14: vec_1 and vec_2: mismatch. Left iterator at end right iterator at 30
C++14 vec_1 v. vec_2 modified: mismatch. Left iterator at 15 right iterator at 42
C++14 vec_3 v. vec_4 with pred: match.
C++14 vec_3 v. modified vec_4 with pred: mismatch. Left iterator at 60 right iterator at 31
C++14: vec_1 and list_1 are a mismatch: false
Press a key
*/
<alg>移動
移動與所指定範圍相關聯的項目。
template<class InputIterator, class OutputIterator>
OutputIterator move(
InputIterator _First,
InputIterator _Last,
OutputIterator _Dest
);
參數
_First
輸入迭代器，表示項目移動範圍的開始位置。
_Last
輸入迭代器，表示項目移動範圍的結束位置。
_Dest
要包含已移動項目的輸出迭代器。
備註
範本函式會評估*(``_Dest``+ N) =移動(*(``_First``+ N)))每個N範圍中[0, _Last - _First``)，嚴格地增加值N從最低值開始。 它接著會傳回 _Dest + N。 如果 _Dest和 _First 指定儲存區域， _Dest 不得在範圍 [``_First``, _Last``)內。
move_backward
將一個迭代器的項目移至另一個迭代器。 從指定範圍內的最後一個項目開始移動，並以該範圍內的第一個項目結束。
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 move_backward(
BidirectionalIterator1 _First,
BidirectionalIterator1 _Last,
BidirectionalIterator2 _DestEnd
);
參數
_First
迭代器，表示要從中移動項目的範圍的開頭。
_Last
表示要從中移動項目的範圍結尾迭代器。 這個項目不會移動。
_DestEnd
雙向迭代器，在目的範圍中越過最後一個項目的位置定址。
備註
範本函式會評估*(``_DestEnd - N - 1) = move``(*(``_Last - N - 1)))每個N範圍中[0, _Last - _First``)，嚴格地增加值N從最低值開始。 It then returns _DestEnd - (``_Last - _First``). 如果_DestEnd和_First指定儲存區域，_DestEnd不能在範圍[``_First``, _Last``)。
move和move_backward的功能等同於使用copy和copy_backward與移動迭代器。
next_permutation
重新排列範圍的項目，讓原始順序由語彙方面下一個較大的排列取代 (如果有的話)，其中下一個的意義可由二元述詞指定。
template<class BidirectionalIterator>
bool next_permutation(BidirectionalIterator _First, BidirectionalIteratorLast);
template<class BidirectionalIterator, class BinaryPredicate>
bool next_permutation(BidirectionalIterator _First, BidirectionalIteratorLast, BinaryPredicate _Comp);
參數
_First
雙向迭代器指向範圍中第一個元素的位置會置換。
_Last
雙向迭代器指向一個之後的位置的最終項目範圍中被置換。
_Comp
使用者定義的述詞函式定義順序中後續項目應符合的比較準則的物件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
true語彙方面下一個排列存在，且已取代原始順序的範圍; 否則false，在此情況下的順序會轉換成進行字彙上的最小排列。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
預設二元述詞是小於和範圍中的項目必須是小於比較，以確保下一步排列正確定義。
複雜性為線性與最多 ( _Last – _First) / 2 會交換。
範例
// alg_next_perm.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt
{
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) {m_nVal =
rhs.m_nVal; return *this;}
bool operator<( const CInt& rhs ) const
{ return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<( ostream& osIn, const CInt& rhs );
private:
int m_nVal;
};
inline ostream& operator<<( ostream& osIn, const CInt& rhs )
{
osIn << "CInt( " << rhs.m_nVal << " )";
return osIn;
}
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
};
int main( )
{
// Reordering the elements of type CInt in a deque
// using the prev_permutation algorithm
CInt c1 = 5, c2 = 1, c3 = 10;
bool deq1Result;
deque<CInt> deq1, deq2, deq3;
deque<CInt>::iterator d1_Iter;
deq1.push_back ( c1 );
deq1.push_back ( c2 );
deq1.push_back ( c3 );
cout << "The original deque of CInts is deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl;
deq1Result = next_permutation ( deq1.begin ( ) , deq1.end ( ) );
if ( deq1Result )
cout << "The lexicographically next permutation "
<< "exists and has\nreplaced the original "
<< "ordering of the sequence in deq1." << endl;
else
cout << "The lexicographically next permutation doesn't "
<< "exist\n and the lexicographically "
<< "smallest permutation\n has replaced the "
<< "original ordering of the sequence in deq1." << endl;
cout << "After one application of next_permutation,\n deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl << endl;
// Permuting vector elements with binary function mod_lesser
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = -3 ; i <= 3 ; i++ )
{
v1.push_back( i );
}
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
next_permutation ( v1.begin ( ) , v1.end ( ) , mod_lesser );
cout << "After the first next_permutation, vector v1 is:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
int iii = 1;
while ( iii <= 5 ) {
next_permutation ( v1.begin ( ) , v1.end ( ) , mod_lesser );
cout << "After another next_permutation of vector v1,\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ;Iter1 ++ )
cout << *Iter1 << " ";
cout << ")." << endl;
iii++;
}
}
The original deque of CInts is deq1 = ( CInt( 5 ), CInt( 1 ), CInt( 10 ) ).
The lexicographically next permutation exists and has
replaced the original ordering of the sequence in deq1.
After one application of next_permutation,
deq1 = ( CInt( 5 ), CInt( 10 ), CInt( 1 ) ).
Vector v1 is ( -3 -2 -1 0 1 2 3 ).
After the first next_permutation, vector v1 is:
v1 = ( -3 -2 -1 0 1 3 2 ).
After another next_permutation of vector v1,
v1 = ( -3 -2 -1 0 2 1 3 ).
After another next_permutation of vector v1,
v1 = ( -3 -2 -1 0 2 3 1 ).
After another next_permutation of vector v1,
v1 = ( -3 -2 -1 0 3 1 2 ).
After another next_permutation of vector v1,
v1 = ( -3 -2 -1 0 3 2 1 ).
After another next_permutation of vector v1,
v1 = ( -3 -2 -1 1 0 2 3 ).
nth_element
分割範圍的項目正確放n個項目範圍中的順序，讓它前面的所有項目都小於或等於它，而且序列中在它後面的所有項目會大於或等於它。
template<class RandomAccessIterator>
void nth_element( RandomAccessIterator _First, RandomAccessIterator _Nth, RandomAccessIteratorLast);
template<class RandomAccessIterator, class BinaryPredicate>
void nth_element( RandomAccessIterator _First, RandomAccessIterator _Nth, RandomAccessIteratorLast, BinaryPredicate _Comp);
參數
_First
隨機存取迭代器定址範圍中的第一個項目的位置進行資料分割。
_Nth
隨機存取迭代器定址的項目位置在資料分割的界限上時，可以正確排序。
_Last
隨機存取迭代器定址超過範圍中最後一個項目的其中一個位置進行資料分割。
_Comp
使用者定義的述詞函式定義順序中後續項目應符合的比較準則的物件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
nth_element演算法並不保證子範圍中的項目可以是側的n個項目排序。 因此會比有較少的保證partial_sort，以下是所選的項目範圍中排序項目以及可用來做更快的替代方式partial_sort當排序較低的範圍不是必要。
項目是相等的但不是一定是相等，如果沒有小於另。
排序複雜度的平均值是以線性*_Last – _First*。
範例
// alg_nth_elem.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether first element is greater than the second
bool UDgreater ( int elem1, int elem2 ) {
return elem1 > elem2;
}
int main() {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 5 ; i++ )
v1.push_back( 3 * i );
int ii;
for ( ii = 0 ; ii <= 5 ; ii++ )
v1.push_back( 3 * ii + 1 );
int iii;
for ( iii = 0 ; iii <= 5 ; iii++ )
v1.push_back( 3 * iii +2 );
cout << "Original vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
nth_element(v1.begin( ), v1.begin( ) + 3, v1.end( ) );
cout << "Position 3 partitioned vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To sort in descending order, specify binary predicate
nth_element( v1.begin( ), v1.begin( ) + 4, v1.end( ),
greater<int>( ) );
cout << "Position 4 partitioned (greater) vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
random_shuffle( v1.begin( ), v1.end( ) );
cout << "Shuffled vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// A user-defined (UD) binary predicate can also be used
nth_element( v1.begin( ), v1.begin( ) + 5, v1.end( ), UDgreater );
cout << "Position 5 partitioned (UDgreater) vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
}
none_of
當條件從未出現在指定的範圍中的項目時，傳回 true。
template<class InputIterator, class BinaryPredicate>
bool none_of(InputIterator _First, InputIterator _Last, BinaryPredicate _Comp);
參數
_First
輸入迭代器，表示要檢查符合條件的項目範圍的開始位置。
_Last
輸入迭代器，指出項目範圍的結尾。
_Comp
若要測試的條件。 這被提供使用者定義的述詞函式物件所定義的條件。 述詞會採用單一引數並傳回true或false。
傳回值
傳回true如果條件未偵測到至少一次在指定的範圍，以及false如果偵測到的條件。
備註
樣板函式傳回true才，某些N範圍[0, _Last - _First``)，述詞_Comp``(*(``_First``+ N))總是false。
partial_sort
將範圍中指定的較小項目數目排列成非遞減排列，或是依據二元述詞指定的順序準則。
template<class RandomAccessIterator>
void partial_sort(
RandomAccessIterator first,
RandomAccessIterator sortEnd,
RandomAccessIterator last
);
template<class RandomAccessIterator, class BinaryPredicate>
void partial_sort(
RandomAccessIterator first,
RandomAccessIterator sortEnd,
RandomAccessIterator last
BinaryPredicate comp
);
參數
first
隨機存取迭代器，用於定址要排序之範圍中第一個項目的位置。
sortEnd
隨機存取迭代器定址子範圍中最後一個元素之後的第一個位置來排序。
last
隨機存取迭代器定址超過一個位置的最終項目範圍中要部分排序。
comp
使用者定義的述詞函式定義順序中後續項目應符合的比較準則的物件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
項目是相等的但不是一定是相等，如果沒有小於另。 排序演算法不穩定，而且不保證會保留對等項目的相對順序。 此演算法stable_sort會保留此原始順序。
The average partial sort complexity is O(( last- first) log ( sortEnd- first)).
範例
// alg_partial_sort.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether first element is greater than the second
bool UDgreater ( int elem1, int elem2 )
{
return elem1 > elem2;
}
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 2 * i );
}
int ii;
for ( ii = 0 ; ii <= 5 ; ii++ )
{
v1.push_back( 2 * ii +1 );
}
cout << "Original vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
partial_sort(v1.begin( ), v1.begin( ) + 6, v1.end( ) );
cout << "Partially sorted vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To partially sort in descending order, specify binary predicate
partial_sort(v1.begin( ), v1.begin( ) + 4, v1.end( ), greater<int>( ) );
cout << "Partially resorted (greater) vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// A user-defined (UD) binary predicate can also be used
partial_sort(v1.begin( ), v1.begin( ) + 8, v1.end( ),
UDgreater );
cout << "Partially resorted (UDgreater) vector:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
}
Original vector:
v1 = ( 0 2 4 6 8 10 1 3 5 7 9 11 )
Partially sorted vector:
v1 = ( 0 1 2 3 4 5 10 8 6 7 9 11 )
Partially resorted (greater) vector:
v1 = ( 11 10 9 8 0 1 2 3 4 5 6 7 )
Partially resorted (UDgreater) vector:
v1 = ( 11 10 9 8 7 6 5 4 0 1 2 3 )
partial_sort_copy
從來源範圍將項目複製到目的範圍，其中來源項目是依小於排序，或依據二元述詞指定的順序準則。
template<class InputIterator, class RandomAccessIterator>
RandomAccessIterator partial_sort_copy(
InputIterator _First1,
InputIterator _Last1,
RandomAccessIterator _First2,
RandomAccessIteratorLast2 );
template<class InputIterator, class RandomAccessIterator, class BinaryPredicate>
RandomAccessIterator partial_sort_copy(
InputIterator _First1,
InputIterator _Last1,
RandomAccessIterator _First2,
RandomAccessIteratorLast2,
BinaryPredicate _Comp);
參數
_First1
輸入迭代器，在來源範圍的第一個項目位置定址。
_Last1
輸入迭代器定址超過一個位置的最後一個元素為來源範圍中。
_First2
隨機存取迭代器已排序的目的範圍中第一個項目的位置定址。
_Last2
隨機存取迭代器定址超過一個位置的最終項目已排序的目的範圍中。
_Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true，不符合時則傳回 false。
傳回值
隨機存取迭代器定址目的範圍之外一個位置的最後一個元素中的項目插入從來源範圍。
備註
來源和目的範圍不得重疊，而且必須是有效的。所有指標必須都可以取值，而且在每個序列的最後一個位置必須都可從第一個可透過遞增。
二元述詞必須提供嚴格弱式排序，因此並不相同的項目已排序，但對等項目。 兩個項目相同下小於相比，但相等，如果沒有不一定會小於另。
範例
// alg_partial_sort_copy.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <iostream>
int main() {
using namespace std;
vector<int> v1, v2;
list<int> list1;
vector<int>::iterator iter1, iter2;
list<int>::iterator list1_Iter, list1_inIter;
int i;
for (i = 0; i <= 9; i++)
v1.push_back(i);
random_shuffle(v1.begin(), v1.end());
list1.push_back(60);
list1.push_back(50);
list1.push_back(20);
list1.push_back(30);
list1.push_back(40);
list1.push_back(10);
cout << "Vector v1 = ( " ;
for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
cout << *iter1 << " ";
cout << ")" << endl;
cout << "List list1 = ( " ;
for (list1_Iter = list1.begin();
list1_Iter!= list1.end();
list1_Iter++)
cout << *list1_Iter << " ";
cout << ")" << endl;
// Copying a partially sorted copy of list1 into v1
vector<int>::iterator result1;
result1 = partial_sort_copy(list1.begin(), list1.end(),
v1.begin(), v1.begin() + 3);
cout << "List list1 Vector v1 = ( " ;
for (iter1 = v1.begin() ; iter1 != v1.end() ; iter1++)
cout << *iter1 << " ";
cout << ")" << endl;
cout << "The first v1 element one position beyond"
<< "\n the last L 1 element inserted was " << *result1
<< "." << endl;
// Copying a partially sorted copy of list1 into v2
int ii;
for (ii = 0; ii <= 9; ii++)
v2.push_back(ii);
random_shuffle(v2.begin(), v2.end());
vector<int>::iterator result2;
result2 = partial_sort_copy(list1.begin(), list1.end(),
v2.begin(), v2.begin() + 6);
cout << "List list1 into Vector v2 = ( " ;
for (iter2 = v2.begin() ; iter2 != v2.end(); iter2++)
cout << *iter2 << " ";
cout << ")" << endl;
cout << "The first v2 element one position beyond"
<< "\n the last L 1 element inserted was " << *result2
<< "." << endl;
}
資料分割
將範圍中的項目分類為兩個斷續集合，而滿足一元述詞的項目在無法滿足一元述詞的項目之前。
template<class BidirectionalIterator, class Predicate>
BidirectionalIterator partition(
BidirectionalIterator _First,
BidirectionalIterator _Last,
Predicate _Comp
);
參數
_First
雙向迭代器定址範圍中的第一個項目的位置進行資料分割。
_Last
雙向迭代器定址超過範圍中最後一個項目的其中一個位置來進行資料分割。
_Comp
使用者定義的述詞函式會定義要分類的項目是否符合條件的物件。 述詞會採用單一引數並傳回true或false。
傳回值
雙向迭代器定址範圍中第一個元素的位置不符合述詞的條件。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
Elements a and b are equivalent, but not necessarily equal, if both Pr ( a, b) is false and Pr ( b, a) if false, where Pr is the parameter-specified predicate. 分割演算法不穩定，而且不保證會保留對等項目的相對順序。 此演算法stable_ 分割會保留此原始順序。
複雜性為線性︰ 有 ( _Last – _First) 應用程式的_Comp最多 ( _Last – _First) / 2 會交換。
範例
// alg_partition.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
bool greater5 ( int value ) {
return value >5;
}
int main( ) {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 0 ; i <= 10 ; i++ )
{
v1.push_back( i );
}
random_shuffle( v1.begin( ), v1.end( ) );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Partition the range with predicate greater10
partition ( v1.begin( ), v1.end( ), greater5 );
cout << "The partitioned set of elements in v1 is: ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
partition_copy
將條件是 true 的項目複製到一個目的地，並將條件是 false 的項目複製到另一個目的地。 項目必須來自指定的範圍。
template<class InputIterator, class OutputIterator1, class OutputIterator2, class Predicate>
pair<OutputIterator1, OutputIterator2>
partition_copy(
InputIterator _First,
InputIterator _Last,
OutputIterator1 _Dest1,
OutputIterator2 _Dest2,
Predicate _Pred
);
參數
_First
輸入迭代器，表示要檢查的條件之範圍的開頭。
_Last
輸入迭代器，指出範圍的結尾。
_Dest1
輸出迭代器，用來將傳回 true 的條件的項目複製測試使用_Pred。
_Dest2
輸出迭代器，用來將傳回 false 條件的項目複製測試使用_Pred。
_Pred
若要測試的條件。 這被提供使用者定義的述詞函式物件定義所要測試條件。 述詞會採用單一引數並傳回true或false。
備註
樣板函式會將每個項目複製X中[``_First``,``_Last``)至*``_Dest1``++如果_Pred``(X)為 true，或*``_Dest2``++ if not。 它會傳回pair<OutputIterator1, OutputIterator2>(``_Dest1``, _Dest2``)。
partition_point
傳回給定範圍中不滿足條件的第一個項目。 排序項目，以便滿足條件的項目在不滿足條件的項目之前。
template<class ForwardIterator, class Predicate>
ForwardIterator partition_point(
ForwardIterator _First,
ForwardIterator _Last,
Predicate _Comp
);
參數
_First
A ForwardIterator ，表示要檢查是否符合條件的範圍的開頭。
_Last
A ForwardIterator ，指出範圍的結尾。
_Comp
若要測試的條件。 這被提供使用者定義的述詞函式物件，定義要搜尋的項目所要符合的條件。 述詞會採用單一引數並傳回true或false。
傳回值
傳回ForwardIterator無法滿足的條件所測試的第一個項目參考_Comp，則會傳回_Last如果找不到。
備註
樣板函式會尋找第一個迭代器it中[``_First``,``_Last``)的_Comp(*it)是false。 必須按照順序_Comp。
pop_heap
從堆積的前面移動最大的項目至範圍的倒數第二個位置，然後從其餘項目形成新的堆積。
template<class RandomAccessIterator>
void pop_heap( RandomAccessIterator _First, RandomAccessIteratorLast);
template<class RandomAccessIterator, class BinaryPredicate>
void pop_heap(RandomAccessIterator _First, RandomAccessIteratorLast, BinaryPredicate _Comp);
參數
_First
隨機存取迭代器堆積中的第一個項目位置定址。
_Last
隨機存取迭代器定址超過一個位置的最終項目在堆積中。
_Comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
pop_heap演算法是 push_heap 演算法，範圍的下一個到最後一個位置處的項目新增到先前的項目，在範圍內，在項目加入至堆積大於任何已在堆積中的項目時的情況下所組成的堆積中所執行之作業的反向作業。
堆積具有兩個屬性︰
第一個項目一定是最大。
可以加入或移除對數時間項目。
堆積是理想的方式實作優先順序佇列，以及使用標準樣板程式庫容器配接器的實作中priority_queue 類別。
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
不包括新加入的項目結尾的範圍必須是堆積。
複雜性為對數，最多需要記錄檔 ( _Last – _First) 比較。
範例
// alg_pop_heap.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 1 ; i <= 9 ; i++ )
v1.push_back( i );
// Make v1 a heap with default less than ordering
random_shuffle( v1.begin( ), v1.end( ) );
make_heap ( v1.begin( ), v1.end( ) );
cout << "The heaped version of vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Add an element to the back of the heap
v1.push_back( 10 );
push_heap( v1.begin( ), v1.end( ) );
cout << "The reheaped v1 with 10 added is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Remove the largest element from the heap
pop_heap( v1.begin( ), v1.end( ) );
cout << "The heap v1 with 10 removed is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl << endl;
// Make v1 a heap with greater-than ordering with a 0 element
make_heap ( v1.begin( ), v1.end( ), greater<int>( ) );
v1.push_back( 0 );
push_heap( v1.begin( ), v1.end( ), greater<int>( ) );
cout << "The 'greater than' reheaped v1 puts the smallest "
<< "element first:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Application of pop_heap to remove the smallest element
pop_heap( v1.begin( ), v1.end( ), greater<int>( ) );
cout << "The 'greater than' heaped v1 with the smallest element\n "
<< "removed from the heap is: ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
prev_permutation
讓原始順序由進行字彙上先前更大的排列取代，如果存在，其中可由二元述詞指定先前的意義，重新排列範圍中的項目。
template<class BidirectionalIterator>
bool prev_permutation(
BidirectionalIterator _First,
BidirectionalIterator _Last
);
template<class BidirectionalIterator, class BinaryPredicate>
bool prev_permutation(
BidirectionalIterator _First,
BidirectionalIterator _Last,
BinaryPredicate _Comp
);
參數
_First
雙向迭代器指向範圍中第一個元素的位置會置換。
_Last
雙向迭代器指向一個之後的位置的最終項目範圍中被置換。
_Comp
使用者定義的述詞函式定義順序中後續項目應符合的比較準則的物件。 二元述詞會採用兩個引數，並且在符合時傳回 true，不符合時則傳回 false。
傳回值
true如果先前辭典編纂順序排列存在且已取代原始順序的範圍;否則false，在此情況下的順序會轉換成進行字彙上的最大的排列。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
預設二元述詞是小於和範圍中的項目必須是小於-比可比較，以確保先前排列是妥善定義。
最多為線性具有複雜度 ( _Last – _First) / 2 會交換。
範例
// alg_prev_perm.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
#include <ostream>
using namespace std;
class CInt;
ostream& operator<<( ostream& osIn, const CInt& rhs );
class CInt {
public:
CInt( int n = 0 ) : m_nVal( n ){}
CInt( const CInt& rhs ) : m_nVal( rhs.m_nVal ){}
CInt& operator=( const CInt& rhs ) {m_nVal =
rhs.m_nVal; return *this;}
bool operator<( const CInt& rhs ) const
{return ( m_nVal < rhs.m_nVal );}
friend ostream& operator<<( ostream& osIn, const CInt& rhs );
private:
int m_nVal;
};
inline ostream& operator<<( ostream& osIn, const CInt& rhs ) {
osIn << "CInt( " << rhs.m_nVal << " )";
return osIn;
}
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 ) {
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
};
int main() {
// Reordering the elements of type CInt in a deque
// using the prev_permutation algorithm
CInt c1 = 1, c2 = 5, c3 = 10;
bool deq1Result;
deque<CInt> deq1, deq2, deq3;
deque<CInt>::iterator d1_Iter;
deq1.push_back ( c1 );
deq1.push_back ( c2 );
deq1.push_back ( c3 );
cout << "The original deque of CInts is deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl;
deq1Result = prev_permutation ( deq1.begin ( ) , deq1.end ( ) );
if ( deq1Result )
cout << "The lexicographically previous permutation "
<< "exists and has \nreplaced the original "
<< "ordering of the sequence in deq1." << endl;
else
cout << "The lexicographically previous permutation doesn't "
<< "exist\n and the lexicographically "
<< "smallest permutation\n has replaced the "
<< "original ordering of the sequence in deq1." << endl;
cout << "After one application of prev_permutation,\n deq1 = (";
for ( d1_Iter = deq1.begin( ); d1_Iter != --deq1.end( ); d1_Iter++ )
cout << " " << *d1_Iter << ",";
d1_Iter = --deq1.end( );
cout << " " << *d1_Iter << " )." << endl << endl;
// Permutating vector elements with binary function mod_lesser
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = -3 ; i <= 3 ; i++ )
v1.push_back( i );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
prev_permutation ( v1.begin ( ) , v1.end ( ) , mod_lesser );
cout << "After the first prev_permutation, vector v1 is:\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
int iii = 1;
while ( iii <= 5 ) {
prev_permutation ( v1.begin ( ) , v1.end ( ) , mod_lesser );
cout << "After another prev_permutation of vector v1,\n v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ;Iter1 ++ )
cout << *Iter1 << " ";
cout << ")." << endl;
iii++;
}
}
The original deque of CInts is deq1 = ( CInt( 1 ), CInt( 5 ), CInt( 10 ) ).
The lexicographically previous permutation doesn't exist
and the lexicographically smallest permutation
has replaced the original ordering of the sequence in deq1.
After one application of prev_permutation,
deq1 = ( CInt( 10 ), CInt( 5 ), CInt( 1 ) ).
Vector v1 is ( -3 -2 -1 0 1 2 3 ).
After the first prev_permutation, vector v1 is:
v1 = ( -3 -2 0 3 2 1 -1 ).
After another prev_permutation of vector v1,
v1 = ( -3 -2 0 3 -1 2 1 ).
After another prev_permutation of vector v1,
v1 = ( -3 -2 0 3 -1 1 2 ).
After another prev_permutation of vector v1,
v1 = ( -3 -2 0 2 3 1 -1 ).
After another prev_permutation of vector v1,
v1 = ( -3 -2 0 2 -1 3 1 ).
After another prev_permutation of vector v1,
v1 = ( -3 -2 0 2 -1 1 3 ).
push_heap
將在範圍結尾的項目加入至由範圍中之前項目所組成的現有堆積。
template<class RandomAccessIterator>
void push_heap( RandomAccessIterator _First, RandomAccessIteratorLast );
template<class RandomAccessIterator, class BinaryPredicate>
void push_heap( RandomAccessIterator _First, RandomAccessIteratorLast, BinaryPredicate _Comp);
參數
_First
隨機存取迭代器堆積中的第一個項目位置定址。
_Last
隨機存取迭代器定址超過要轉換成堆積的範圍中最後一個項目的其中一個位置。
_Comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
項目必須先上推至現有的堆積的結尾，則演算法會使用這個項目新增至現有的堆積。
堆積具有兩個屬性︰
第一個項目一定是最大。
可以加入或移除對數時間項目。
堆積是理想的方式實作優先順序佇列，以及使用標準樣板程式庫容器配接器的實作中priority_queue 類別。
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
不包括新加入的項目結尾的範圍必須是堆積。
複雜性為對數，最多需要記錄檔 ( _Last – _First) 比較。
範例
// alg_push_heap.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 1 ; i <= 9 ; i++ )
v1.push_back( i );
random_shuffle( v1.begin( ), v1.end( ) );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Make v1 a heap with default less than ordering
make_heap ( v1.begin( ), v1.end( ) );
cout << "The heaped version of vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Add an element to the heap
v1.push_back( 10 );
cout << "The heap v1 with 10 pushed back is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
push_heap( v1.begin( ), v1.end( ) );
cout << "The reheaped v1 with 10 added is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl << endl;
// Make v1 a heap with greater than ordering
make_heap ( v1.begin( ), v1.end( ), greater<int>( ) );
cout << "The greater-than heaped version of v1 is\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
v1.push_back(0);
cout << "The greater-than heap v1 with 11 pushed back is\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
push_heap( v1.begin( ), v1.end( ), greater<int>( ) );
cout << "The greater than reheaped v1 with 11 added is\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
random_shuffle
Std::random_shuffle() 函式已被取代，取代std::shuffle()。 如需程式碼範例和詳細資訊，請參閱<> >以及 Stackoverflow 文章std:: random_shuffle 方法為何被取代的 C + + 14？。
移除
從指定範圍中排除指定的值，而不會干擾其餘項目的順序，並傳回沒有指定值、新範圍的結尾。
template<class ForwardIterator, class Type>
ForwardIterator remove(ForwardIterator _First, ForwardIteratorLast, const Type& _Val);
參數
_First
轉送迭代器，定址要從中移除元素之範圍中，第一個元素的位置。
_Last
轉送迭代器，定址要從中移除元素之範圍中，最後一個元素的位置後方。
_Val
要從範圍中移除的值。
傳回值
轉送迭代器，定址修改過範圍的新結束位置，也就是指定值外的剩餘序列中，最後一個元素後方的位置。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
未移除之元素的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性;有 ( _Last – _First) 相等比較。
List 類別具有更有效率的成員函式版本的移除，這也會重新連結指標。
範例
// alg_remove.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1, Iter2, new_end;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle ( v1.begin( ), v1.end( ) );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Remove elements with a value of 7
new_end = remove ( v1.begin( ), v1.end( ), 7 );
cout << "Vector v1 with value 7 removed is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To change the sequence size, use erase
v1.erase (new_end, v1.end( ) );
cout << "Vector v1 resized with value 7 removed is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
remove_copy
從來源範圍將項目複製到目的範圍，不過不會複製一個指定值的項目，也不會干擾其餘項目的順序，並傳回新目的範圍結尾。
template<class InputIterator, class OutputIterator, class Type>
OutputIterator remove_copy(InputIterator _First, InputIterator _Last, OutputIterator _Result, const Type& _Val);
參數
_First
輸入迭代器，用於定址要從中移除元素的範圍中，第一個元素的位置。
_Last
輸入迭代器，用於定址要從中移除元素的範圍中，最後一個元素的後面一個位置。
_Result
輸出迭代器，用於定址要移除項目的目的範圍中，第一個項目的位置。
_Val
要從範圍中移除的值。
傳回值
正向迭代器，用於定址目的範圍的新結束位置，也就是指定值外的剩餘序列複本中，最後一個項目的後面一個位置。
備註
參考的來源和目的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
目的範圍中的空間必須足以包含要在移除指定值的項目之後複製的剩餘項目。
未移除之元素的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性;有 ( _Last – _First) 比較是否相等，而且最 ( _Last – _First) 指派。
範例
// alg_remove_copy.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
using namespace std;
vector <int> v1, v2(10);
vector <int>::iterator Iter1, Iter2, new_end;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle (v1.begin( ), v1.end( ) );
cout << "The original vector v1 is: ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Remove elements with a value of 7
new_end = remove_copy ( v1.begin( ), v1.end( ), v2.begin( ), 7 );
cout << "Vector v1 is left unchanged as ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Vector v2 is a copy of v1 with the value 7 removed:\n ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
}
remove_copy_if
從來源範圍將項目複製到目的範圍，不過不會複製滿足述詞的項目，也不會干擾其餘項目的順序，並傳回新目的範圍結尾。
template<class InputIterator, class OutputIterator, class Predicate>
OutputIterator remove_copy_if(InputIterator _First, InputIterator Last, OutputIterator _Result, Predicate _Pred);
參數
_First
輸入迭代器，用於定址要從中移除元素的範圍中，第一個元素的位置。
_Last
輸入迭代器，用於定址要從中移除元素的範圍中，最後一個元素的後面一個位置。
_Result
輸出迭代器，用於定址要移除元素的目的範圍中，第一個元素的位置。
_Pred
必須符合的一元述詞，也就是要被取代的元素值。
傳回值
正向迭代器，用於定址目的範圍的新結束位置，也就是符合述詞之元素外的剩餘序列中，最後一個項目的後面一個位置。
備註
參考的來源範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
目的範圍中的空間必須足以包含要在移除指定值的元素之後複製的剩餘元素。
未移除之元素的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性︰ 有 ( _Last – _First) 比較是否相等，而且最 ( _Last – _First) 指派。
如需這些函式運作方式的資訊，請參閱 Checked Iterators。
範例
// alg_remove_copy_if.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
bool greater6 ( int value ) {
return value >6;
}
int main() {
using namespace std;
vector <int> v1, v2(10);
vector <int>::iterator Iter1, Iter2, new_end;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle ( v1.begin( ), v1.end( ) );
cout << "The original vector v1 is: ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Remove elements with a value greater than 6
new_end = remove_copy_if ( v1.begin( ), v1.end( ),
v2.begin( ), greater6 );
cout << "After the appliation of remove_copy_if to v1,\n "
<< "vector v1 is left unchanged as ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Vector v2 is a copy of v1 with values greater "
<< "than 6 removed:\n ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != new_end ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
}
remove_if
從指定範圍中排除滿足述詞的項目，而不會干擾其餘項目的順序，並傳回沒有指定值、新範圍的結尾。
template<class ForwardIterator, class Predicate>
ForwardIterator remove_if(ForwardIterator _First, ForwardIteratorLast, Predicate _Pred);
參數
_First
正向迭代器指向要從中移除項目範圍中第一個項目的位置。
_Last
正向迭代器指向第一個位置超過從中移除元素之範圍中的最後一個項目。
_Pred
必須符合的一元述詞，也就是要被取代的元素值。
傳回值
轉送迭代器，定址修改過範圍的新結束位置，也就是指定值外的剩餘序列中，最後一個元素後方的位置。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
未移除之元素的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性︰ 有 ( _Last – _First) 相等比較。
清單中有更有效率的成員函式版本的 [移除]，會重新連結指標。
範例
// alg_remove_if.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
bool greater6 ( int value ) {
return value >6;
}
int main( ) {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2, new_end;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle ( v1.begin( ), v1.end( ) );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Remove elements satisfying predicate greater6
new_end = remove_if (v1.begin( ), v1.end( ), greater6 );
cout << "Vector v1 with elements satisfying greater6 removed is\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To change the sequence size, use erase
v1.erase (new_end, v1.end( ) );
cout << "Vector v1 resized elements satisfying greater6 removed is\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
取代
檢查範圍內的每個項目，如果符合指定的值則予以取代。
template<class ForwardIterator, class Type>
void replace(ForwardIterator _First, ForwardIteratorLast, const Type& _OldVal, const Type& _NewVal);
參數
_First
正向迭代器指向的取代項目範圍中第一個項目的位置。
_Last
正向迭代器指向第一個位置超過會被取代項目範圍中最後一個項目。
_OldVal
所取代之項目的舊值。
_NewVal
要指派給具有舊值之項目的新值。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
未取代之項目的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性;有 ( _Last – _First) 比較是否相等，而且最 ( _Last – _First) 指派新值。
範例
// alg_replace.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle (v1.begin( ), v1.end( ) );
cout << "The original vector v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Replace elements with a value of 7 with a value of 700
replace (v1.begin( ), v1.end( ), 7 , 700);
cout << "The vector v1 with a value 700 replacing that of 7 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
replace_copy
檢查來源範圍內的每個項目，如果符合指定的值則予以取代，同時將結果複製到新目的範圍。
template<class InputIterator, class OutputIterator, class Type>
OutputIterator replace_copy(
InputIterator _First,
InputIterator _Last,
OutputIterator _Result,
const Type& _OldVal,
const Type& _NewVal);
參數
_First
輸入迭代器，用於指向要從中取代項目的範圍中，第一個項目的位置。
_Last
輸入迭代器，用於指向要從中取代項目的範圍中，最後一個項目的後面一個位置。
_Result
輸出迭代器，用於指向要複製已更改順序的項目之目的範圍中，第一個項目的位置。
_OldVal
所取代之項目的舊值。
_NewVal
要指派給具有舊值之項目的新值。
傳回值
輸出迭代器，用於指向要複製已更改順序的元素之目的範圍中，最後一個元素的後面一個位置。
備註
參考的來源和目的範圍不得重疊且必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
未取代之項目的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性︰ 有 ( _Last – _First) 比較是否相等，而且最 ( _Last – _First) 指派新值。
範例
// alg_replace_copy.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1;
list <int> L1 (15);
vector <int>::iterator Iter1;
list <int>::iterator L_Iter1;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle ( v1.begin( ), v1.end( ) );
int iii;
for ( iii = 0 ; iii <= 15 ; iii++ )
v1.push_back( 1 );
cout << "The original vector v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Replace elements in one part of a vector with a value of 7
// with a value of 70 and copy into another part of the vector
replace_copy ( v1.begin( ), v1.begin( ) + 14,v1.end( ) -15, 7 , 70);
cout << "The vector v1 with a value 70 replacing that of 7 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Replace elements in a vector with a value of 70
// with a value of 1 and copy into a list
replace_copy ( v1.begin( ), v1.begin( ) + 14,L1.begin( ), 7 , 1);
cout << "The list copy L1 of v1 with the value 0 replacing "
<< "that of 7 is:\n ( " ;
for ( L_Iter1 = L1.begin( ) ; L_Iter1 != L1.end( ) ; L_Iter1++ )
cout << *L_Iter1 << " ";
cout << ")." << endl;
}
replace_copy_if
檢查來源範圍內的每個項目，如果滿足指定的述詞則予以取代，同時將結果複製到新目的範圍。
template<class InputIterator, class OutputIterator, class Predicate, class Type>
OutputIterator replace_copy_if(
InputIterator _First,
InputIterator _Last,
OutputIterator _Result,
Predicate _Pred,
const Type& _Val);
參數
_First
輸入迭代器，用於指向要從中取代項目的範圍中，第一個項目的位置。
_Last
輸入迭代器，用於指向要從中取代項目的範圍中，最後一個項目的後面一個位置。
_Result
輸出迭代器，用於指向要複製項目之目的範圍中，第一個項目的位置。
_Pred
必須符合的一元述詞，也就是要被取代的項目值。
_Val
要指派給其舊值符合此述詞之項目的新值。
傳回值
輸出迭代器，用於指向要複製已更改順序的元素之目的範圍中，最後一個元素的後面一個位置。
備註
參考的來源和目的範圍不得重疊且必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
未取代之項目的順序會保持穩定。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性;有 ( _Last – _First) 比較是否相等，而且最 ( _Last – _First) 指派新值。
範例
// alg_replace_copy_if.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
bool greater6 ( int value ) {
return value >6;
}
int main( ) {
using namespace std;
vector <int> v1;
list <int> L1 (13);
vector <int>::iterator Iter1;
list <int>::iterator L_Iter1;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle ( v1.begin( ), v1.end( ) );
int iii;
for ( iii = 0 ; iii <= 13 ; iii++ )
v1.push_back( 1 );
cout << "The original vector v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Replace elements with a value of 7 in the 1st half of a vector
// with a value of 70 and copy it into the 2nd half of the vector
replace_copy_if ( v1.begin( ), v1.begin( ) + 14,v1.end( ) -14,
greater6 , 70);
cout << "The vector v1 with values of 70 replacing those greater"
<< "\n than 6 in the 1st half & copied into the 2nd half is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Replace elements in a vector with a value of 70
// with a value of 1 and copy into a list
replace_copy_if ( v1.begin( ), v1.begin( ) + 13,L1.begin( ),
greater6 , -1 );
cout << "A list copy of vector v1 with the value -1\n replacing "
<< "those greater than 6 is:\n ( " ;
for ( L_Iter1 = L1.begin( ) ; L_Iter1 != L1.end( ) ; L_Iter1++ )
cout << *L_Iter1 << " ";
cout << ")." << endl;
}
replace_if
檢查範圍內的每個項目，如果滿足指定的述詞則予以取代。
template<class ForwardIterator, class Predicate, class Type>
void replace_if(ForwardIterator _First, ForwardIteratorLast, Predicate _Pred, const Type& _Val);
參數
_First
正向迭代器指向的取代項目範圍中第一個項目的位置。
_Last
指向第一個位置，過去的取代項目範圍中最後一個項目的迭代器。
_Pred
必須符合的一元述詞，也就是要被取代的元素值。
_Val
要指派給其舊值符合此述詞之項目的新值。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
未取代之項目的順序會保持穩定。
此演算法replace_if是演算法的一般化取代，允許任何述詞來指定，而不是等號比較指定的常數值。
用來判斷元素是否相等的 operator== 必須在其運算元之間具有對等關聯。
複雜性為線性︰ 有 ( _Last – _First) 比較是否相等，而且最 ( _Last – _First) 指派新值。
範例
// alg_replace_if.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
bool greater6 ( int value ) {
return value >6;
}
int main( ) {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 9 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
v1.push_back( 7 );
random_shuffle ( v1.begin( ), v1.end( ) );
cout << "The original vector v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Replace elements satisfying the predicate greater6
// with a value of 70
replace_if ( v1.begin( ), v1.end( ), greater6 , 70);
cout << "The vector v1 with a value 70 replacing those\n "
<< "elements satisfying the greater6 predicate is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
反向
反轉範圍內項目的順序。
template<class BidirectionalIterator>
void reverse(BidirectionalIterator _First, BidirectionalIteratorLast);
參數
_First
雙向迭代器指向的項目被置換的範圍中第一個項目的位置。
_Last
雙向迭代器指向一個之後的位置的最終項目中的項目被置換所在的範圍。
備註
參考的來源範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
範例
// alg_reverse.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 9 ; i++ )
{
v1.push_back( i );
}
cout << "The original vector v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Reverse the elements in the vector
reverse (v1.begin( ), v1.end( ) );
cout << "The modified vector v1 with values reversed is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
The original vector v1 is:
( 0 1 2 3 4 5 6 7 8 9 ).
The modified vector v1 with values reversed is:
( 9 8 7 6 5 4 3 2 1 0 ).
reverse_copy
反轉來源範圍內項目的順序，並將其複製到目的範圍
template<class BidirectionalIterator, class OutputIterator>
OutputIterator reverse_copy(
BidirectionalIterator _First,
BidirectionalIterator Last,
OutputIterator _Result);
參數
_First
雙向迭代器，用於指向要排列的來源範圍中，第一個元素的位置。
_Last
雙向迭代器，用於指向要排列元素的來源範圍中，最後一個元素的後面一個位置。
_Result
輸出迭代器，用於指向要複製元素之目的範圍中，第一個元素的位置。
傳回值
輸出迭代器，用於指向要複製已更改順序的元素之目的範圍中，最後一個元素的後面一個位置。
備註
參考的來源和目的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
範例
// alg_reverse_copy.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1, v2( 10 );
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 0 ; i <= 9 ; i++ )
{
v1.push_back( i );
}
cout << "The original vector v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Reverse the elements in the vector
reverse_copy (v1.begin( ), v1.end( ), v2.begin( ) );
cout << "The copy v2 of the reversed vector v1 is:\n ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
cout << "The original vector v1 remains unmodified as:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
旋轉
交換兩個相鄰範圍的項目。
template<class ForwardIterator>
void rotate(ForwardIterator _First, ForwardIterator _Middle, ForwardIteratorLast);
參數
_First
正向迭代器，用於定址要旋轉之範圍中第一個項目的位置。
_Middle
定義範圍內界限的正向迭代器，用於定址第二個範圍部分中第一個項目的位置，該部分的項目會與第一個範圍部分的項目交換。
_ Last
正向迭代器，用於定址要旋轉之範圍中最後一個項目的後面一個位置。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
複雜性為線性與最多 ( _Last – _First) 交換。
範例
// alg_rotate.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
int main( ) {
using namespace std;
vector <int> v1;
deque <int> d1;
vector <int>::iterator v1Iter1;
deque<int>::iterator d1Iter1;
int i;
for ( i = -3 ; i <= 5 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii =0 ; ii <= 5 ; ii++ )
{
d1.push_back( ii );
}
cout << "Vector v1 is ( " ;
for ( v1Iter1 = v1.begin( ) ; v1Iter1 != v1.end( ) ;v1Iter1 ++ )
cout << *v1Iter1 << " ";
cout << ")." << endl;
rotate ( v1.begin ( ) , v1.begin ( ) + 3 , v1.end ( ) );
cout << "After rotating, vector v1 is ( " ;
for ( v1Iter1 = v1.begin( ) ; v1Iter1 != v1.end( ) ;v1Iter1 ++ )
cout << *v1Iter1 << " ";
cout << ")." << endl;
cout << "The original deque d1 is ( " ;
for ( d1Iter1 = d1.begin( ) ; d1Iter1 != d1.end( ) ;d1Iter1 ++ )
cout << *d1Iter1 << " ";
cout << ")." << endl;
int iii = 1;
while ( iii <= d1.end ( ) - d1.begin ( ) ) {
rotate ( d1.begin ( ) , d1.begin ( ) + 1 , d1.end ( ) );
cout << "After the rotation of a single deque element to the back,\n d1 is ( " ;
for ( d1Iter1 = d1.begin( ) ; d1Iter1 != d1.end( ) ;d1Iter1 ++ )
cout << *d1Iter1 << " ";
cout << ")." << endl;
iii++;
}
}
Vector v1 is ( -3 -2 -1 0 1 2 3 4 5 ).
After rotating, vector v1 is ( 0 1 2 3 4 5 -3 -2 -1 ).
The original deque d1 is ( 0 1 2 3 4 5 ).
After the rotation of a single deque element to the back,
d1 is ( 1 2 3 4 5 0 ).
After the rotation of a single deque element to the back,
d1 is ( 2 3 4 5 0 1 ).
After the rotation of a single deque element to the back,
d1 is ( 3 4 5 0 1 2 ).
After the rotation of a single deque element to the back,
d1 is ( 4 5 0 1 2 3 ).
After the rotation of a single deque element to the back,
d1 is ( 5 0 1 2 3 4 ).
After the rotation of a single deque element to the back,
d1 is ( 0 1 2 3 4 5 ).
rotate_copy
交換來源範圍內兩個相鄰範圍的項目，並將結果複製到目的範圍。
template<class ForwardIterator, class OutputIterator>
OutputIterator rotate_copy(
ForwardIterator _First,
ForwardIterator _Middle,
ForwardIteratorLast,
OutputIterator _Result );
參數
_First
正向迭代器，用於定址要旋轉之範圍中第一個項目的位置。
_Middle
定義範圍內界限的正向迭代器，用於定址第二個範圍部分中第一個項目的位置，該部分的項目會與第一個範圍部分的項目交換。
_ Last
正向迭代器，用於定址要旋轉之範圍中最後一個項目的後面一個位置。
_Result
輸出迭代器，用於定址目的範圍中第一個項目的位置。
傳回值
輸出迭代器，用於定址目的範圍中最後一個項目的後面一個位置。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
複雜性為線性與最多 ( _Last – _First) 交換。
範例
// alg_rotate_copy.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
int main() {
using namespace std;
vector <int> v1 , v2 ( 9 );
deque <int> d1 , d2 ( 6 );
vector <int>::iterator v1Iter , v2Iter;
deque<int>::iterator d1Iter , d2Iter;
int i;
for ( i = -3 ; i <= 5 ; i++ )
v1.push_back( i );
int ii;
for ( ii =0 ; ii <= 5 ; ii++ )
d1.push_back( ii );
cout << "Vector v1 is ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ;v1Iter ++ )
cout << *v1Iter << " ";
cout << ")." << endl;
rotate_copy ( v1.begin ( ) , v1.begin ( ) + 3 , v1.end ( ) , v2.begin ( ) );
cout << "After rotating, the vector v1 remains unchanged as:\n v1 = ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ;v1Iter ++ )
cout << *v1Iter << " ";
cout << ")." << endl;
cout << "After rotating, the copy of vector v1 in v2 is:\n v2 = ( " ;
for ( v2Iter = v2.begin( ) ; v2Iter != v2.end( ) ;v2Iter ++ )
cout << *v2Iter << " ";
cout << ")." << endl;
cout << "The original deque d1 is ( " ;
for ( d1Iter = d1.begin( ) ; d1Iter != d1.end( ) ;d1Iter ++ )
cout << *d1Iter << " ";
cout << ")." << endl;
int iii = 1;
while ( iii <= d1.end ( ) - d1.begin ( ) )
{
rotate_copy ( d1.begin ( ) , d1.begin ( ) + iii , d1.end ( ) , d2.begin ( ) );
cout << "After the rotation of a single deque element to the back,\n d2 is ( " ;
for ( d2Iter = d2.begin( ) ; d2Iter != d2.end( ) ;d2Iter ++ )
cout << *d2Iter << " ";
cout << ")." << endl;
iii++;
}
}
搜尋
在目標範圍中搜尋第一個序列，其項目等於指定項目序列中的項目，或在二元述詞指定的意義上，其項目相當於指定序列中的項目。
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search(
ForwardIterator1 _First1,
ForwardIterator1 _Last1,
ForwardIterator2 _First2,
ForwardIterator2 _Last2
);
template<class ForwardIterator1, class ForwardIterator2, class Predicate>
ForwardIterator1 search(
ForwardIterator1 _First1,
ForwardIterator1 _Last1,
ForwardIterator2 _First2,
ForwardIterator2 _Last2
Predicate _Comp
);
參數
_First1
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
_Last1
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
_First2
正向迭代器，其定址要比對範圍中第一個元素的位置。
_Last2
正向迭代器，其定址要比對範圍中最後一個元素之後的位置。
_Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器會定址符合指定序列，或等於二元述詞所指定之意義的第一個子序列的第一個元素的位置。
備註
operator== 用來決定元素及指定值間的比對，是否必須施加其運算元之間的等價關聯。
參考的範圍必須有效;所有指標都必須都可以取值，而且在每個序列的最後一個位置可以從第可透過遞增。
平均複雜性為線性搜尋範圍的大小而言，而且最差的案例複雜度也線性方面要搜尋的序列的大小。
範例
// alg_search.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
// Return whether second element is twice the first
bool twice (int elem1, int elem2 )
{
return 2 * elem1 == elem2;
}
int main( ) {
using namespace std;
vector <int> v1, v2;
list <int> L1;
vector <int>::iterator Iter1, Iter2;
list <int>::iterator L1_Iter, L1_inIter;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
int ii;
for ( ii = 4 ; ii <= 5 ; ii++ )
{
L1.push_back( 5 * ii );
}
int iii;
for ( iii = 2 ; iii <= 4 ; iii++ )
{
v2.push_back( 10 * iii );
}
cout << "Vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
cout << "List L1 = ( " ;
for ( L1_Iter = L1.begin( ) ; L1_Iter!= L1.end( ) ; L1_Iter++ )
cout << *L1_Iter << " ";
cout << ")" << endl;
cout << "Vector v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")" << endl;
// Searching v1 for first match to L1 under identity
vector <int>::iterator result1;
result1 = search (v1.begin( ), v1.end( ), L1.begin( ), L1.end( ) );
if ( result1 == v1.end( ) )
cout << "There is no match of L1 in v1."
<< endl;
else
cout << "There is at least one match of L1 in v1"
<< "\n and the first one begins at "
<< "position "<< result1 - v1.begin( ) << "." << endl;
// Searching v1 for a match to L1 under the binary predicate twice
vector <int>::iterator result2;
result2 = search (v1.begin( ), v1.end( ), v2.begin( ), v2.end( ), twice );
if ( result2 == v1.end( ) )
cout << "There is no match of L1 in v1."
<< endl;
else
cout << "There is a sequence of elements in v1 that "
<< "are equivalent\n to those in v2 under the binary "
<< "predicate twice\n and the first one begins at position "
<< result2 - v1.begin( ) << "." << endl;
}
Vector v1 = ( 0 5 10 15 20 25 0 5 10 15 20 25 )
List L1 = ( 20 25 )
Vector v2 = ( 20 30 40 )
There is at least one match of L1 in v1
and the first one begins at position 4.
There is a sequence of elements in v1 that are equivalent
to those in v2 under the binary predicate twice
and the first one begins at position 2.
search_n
在範圍中搜尋包含指定項目數的第一個子序列，這些項目具有特定值或在二元述詞指定的意義上與該值關聯。
template<class ForwardIterator1, class Diff2, class Type>
ForwardIterator1 search_n(
ForwardIterator1 _First1,
ForwardIterator1 _Last1,
Diff2 _Count,
const Type& _Val
);
template<class ForwardIterator1, class Diff2, class Type, class BinaryPredicate>
ForwardIterator1 search_n(
ForwardIterator1 _First1,
ForwardIterator1 _Last1,
Diff2 _Count,
const Type& _Val,
BinaryPredicate _Comp
);
參數
_First1
正向迭代器，其定址要搜尋範圍中第一個元素的位置。
_Last1
正向迭代器，其定址要搜尋範圍中最後一個元素之後的位置。
_Count
要搜尋的子序列的大小。
_Val
要搜尋的序列中項目的值。
_Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器會定址符合指定序列，或等於二元述詞所指定之意義的第一個子序列的第一個元素的位置。
備註
operator== 用來決定元素及指定值間的比對，是否必須施加其運算元之間的等價關聯。
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
複雜性為線性的搜尋大小而言。
範例
// alg_search_n.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
// Return whether second element is 1/2 of the first
bool one_half ( int elem1, int elem2 )
{
return elem1 == 2 * elem2;
}
int main( )
{
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
for ( i = 0 ; i <= 2 ; i++ )
{
v1.push_back( 5 );
}
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 5 * i );
}
for ( i = 0 ; i <= 2 ; i++ )
{
v1.push_back( 10 );
}
cout << "Vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// Searching v1 for first match to (5 5 5) under identity
vector <int>::iterator result1;
result1 = search_n ( v1.begin( ), v1.end( ), 3, 5 );
if ( result1 == v1.end( ) )
cout << "There is no match for a sequence ( 5 5 5 ) in v1."
<< endl;
else
cout << "There is at least one match of a sequence ( 5 5 5 )"
<< "\n in v1 and the first one begins at "
<< "position "<< result1 - v1.begin( ) << "." << endl;
// Searching v1 for first match to (5 5 5) under one_half
vector <int>::iterator result2;
result2 = search_n (v1.begin( ), v1.end( ), 3, 5, one_half );
if ( result2 == v1.end( ) )
cout << "There is no match for a sequence ( 5 5 5 ) in v1"
<< " under the equivalence predicate one_half." << endl;
else
cout << "There is a match of a sequence ( 5 5 5 ) "
<< "under the equivalence\n predicate one_half "
<< "in v1 and the first one begins at "
<< "position "<< result2 - v1.begin( ) << "." << endl;
}
Vector v1 = ( 0 5 10 15 20 25 5 5 5 0 5 10 15 20 25 10 10 10 )
There is at least one match of a sequence ( 5 5 5 )
in v1 and the first one begins at position 6.
There is a match of a sequence ( 5 5 5 ) under the equivalence
predicate one_half in v1 and the first one begins at position 15.
set_difference
將屬於一個排序來源範圍但不屬於第二個排序來源範圍的所有項目聯集為單一排序的目的範圍，其中順序準則可由二元述詞指定。
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_difference(
InputIterator1 first1,
InputIterator1 last1,
InputIterator2 first2,
InputIterator2 last2,
OutputIterator result );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
OutputIterator set_difference(
InputIterator1 first1,
InputIterator1 last1,
InputIterator2 first2,
InputIterator2 last2,
OutputIterator result,
BinaryPredicate comp );
參數
first1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，第一個元素的位置，此聯集範圍代表兩個來源範圍的差異。
last1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，最後一個元素的後面一個位置，此聯集範圍代表兩個來源範圍的差異。
first2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，第一個元素的位置，此聯集範圍代表兩個來源範圍的差異。
last2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，最後一個元素的後面一個位置，此聯集範圍代表兩個來源範圍的差異。
result
輸出迭代器，用於定址目的範圍中第一個元素的位置，在此目的範圍中，兩個來源範圍會聯集成單一排序範圍，以代表兩個來源範圍的差異。
comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
輸出迭代器，用於定址排序目的範圍中最後一個元素的後面一個位置，此目的範圍代表兩個來源範圍的差異。
備註
參考的排序來源範圍必須有效；所有指標都必須可以取值，而且在每個序列中，必須可透過遞增從第一個位置到達最後一個位置。
目的範圍與任何一個來源範圍都不應該重疊，而且大小應該足以包含第一個來源範圍。
每個排序來源範圍必須根據 set_difference 演算法用來排序結合範圍的相同順序，排列成套用此演算法的前置條件。
這項作業很穩定，因為每個範圍內的元素相對順序會保留在目的範圍中。 演算法 merge 不會修改來源範圍。
輸入迭代器的實值類型必須是小於比較才能建立此順序：因此若提供了兩個元素，可以判斷它們相等 (任一個都不小於另一個的意義)，或者一個小於另一個。 這會導致非對等元件之間的排序。 當兩個來源範圍中有對等元素時，目的範圍之第一個來源範圍中的元素會優先於第二個範圍中的元素。 如果來源範圍包含重複的元素，使得第一個來源範圍中的元素比第二個來源範圍多，則目的範圍會包含第一個來源範圍中這些元素的發生次數超過第二個來源範圍中這些元素的發生次數的數目。
演算法的複雜性為線性最多 2 * (( last1 – first1) – ( last2 – first2)) – 1 非空白的來源範圍的比較。
範例
// alg_set_diff.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 )
{
if (elem1 < 0)
elem1 = - elem1;
if (elem2 < 0)
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1a, v1b, v1 ( 12 );
vector <int>::iterator Iter1a, Iter1b, Iter1, Result1;
// Constructing vectors v1a & v1b with default less-than ordering
int i;
for ( i = -1 ; i <= 4 ; i++ )
{
v1a.push_back( i );
}
int ii;
for ( ii =-3 ; ii <= 0 ; ii++ )
{
v1b.push_back( ii );
}
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vectors v2a & v2b with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
vector <int>::iterator Iter2a, Iter2b, Iter2, Result2;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vectors v3a & v3b with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) , v3 ( v1 );
vector <int>::iterator Iter3a, Iter3b, Iter3, Result3;
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To combine into a difference in asscending
// order with the default binary predicate less <int> ( )
Result1 = set_difference ( v1a.begin ( ) , v1a.end ( ) ,
v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
cout << "Set_difference of source ranges with default order,"
<< "\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To combine into a difference in descending
// order specify binary predicate greater<int>( )
Result2 = set_difference ( v2a.begin ( ) , v2a.end ( ) ,
v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
cout << "Set_difference of source ranges with binary"
<< "predicate greater specified,\n vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != Result2 ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// To combine into a difference applying a user
// defined binary predicate mod_lesser
Result3 = set_difference ( v3a.begin ( ) , v3a.end ( ) ,
v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
cout << "Set_difference of source ranges with binary "
<< "predicate mod_lesser specified,\n vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != Result3 ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
set_intersection
將屬於兩個排序來源範圍的所有項目聯集為單一排序目的範圍，其中順序準則可由二元述詞指定。
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
OutputIterator set_intersection(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result,
BinaryPredicate _Comp );
參數
_First1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，第一個元素的位置，此聯集範圍代表兩個來源範圍的交集。
_Last1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，最後一個元素的後面一個位置，此聯集範圍代表兩個來源範圍的交集。
_First2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，第一個元素的位置，此聯集範圍代表兩個來源範圍的交集。
_Last2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，最後一個元素的後面一個位置，此聯集範圍代表兩個來源範圍的交集。
_ 結果
輸出迭代器，用於定址目的範圍中第一個元素的位置，在此目的範圍中，兩個來源範圍會聯集成單一排序範圍，以代表兩個來源範圍的交集。
_Comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
輸出迭代器，用於定址排序目的範圍中最後一個元素的後面一個位置，此目的範圍代表兩個來源範圍的交集。
備註
參考的排序來源範圍必須有效；所有指標都必須可以取值，而且在每個序列中，必須可透過遞增從第一個位置到達最後一個位置。
目的範圍與任何一個來源範圍都不應該重疊，而且大小應該足以包含目的範圍。
每個排序來源範圍必須根據 merge 演算法用來排序結合範圍的相同順序，排列成套用此演算法的前置條件。
這項作業很穩定，因為每個範圍內的元素相對順序會保留在目的範圍中。 演算法不會修改來源範圍。
輸入迭代器的實值類型必須是小於比較才能建立此順序：因此若提供了兩個元素，可以判斷它們相等 (任一個都不小於另一個的意義)，或者一個小於另一個。 這會導致非對等元件之間的排序。 當兩個來源範圍中有對等元素時，目的範圍之第一個來源範圍中的元素會優先於第二個範圍中的元素。 如果來源範圍包含重複的元素，則目的範圍會包含這些元素同時出現在兩個來源範圍中的最大數量元素。
演算法的複雜性為線性最多 2 * (( _Last1 – _First1) + ( _Last2 – _First2)) – 1 非空白的來源範圍的比較。
範例
// alg_set_intersection.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 ) {
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main() {
using namespace std;
vector <int> v1a, v1b, v1 ( 12 );
vector <int>::iterator Iter1a, Iter1b, Iter1, Result1;
// Constructing vectors v1a & v1b with default less than ordering
int i;
for ( i = -1 ; i <= 3 ; i++ )
v1a.push_back( i );
int ii;
for ( ii =-3 ; ii <= 1 ; ii++ )
v1b.push_back( ii );
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vectors v2a & v2b with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
vector <int>::iterator Iter2a, Iter2b, Iter2, Result2;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vectors v3a & v3b with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) , v3 ( v1 );
vector <int>::iterator Iter3a, Iter3b, Iter3, Result3;
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To combine into an intersection in asscending order with the
// default binary predicate less <int> ( )
Result1 = set_intersection ( v1a.begin ( ) , v1a.end ( ) ,
v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
cout << "Intersection of source ranges with default order,"
<< "\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; ++Iter1 )
cout << *Iter1 << " ";
cout << ")." << endl;
// To combine into an intersection in descending order, specify
// binary predicate greater<int>( )
Result2 = set_intersection ( v2a.begin ( ) , v2a.end ( ) ,
v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
cout << "Intersection of source ranges with binary predicate"
<< " greater specified,\n vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != Result2 ; ++Iter2 )
cout << *Iter2 << " ";
cout << ")." << endl;
// To combine into an intersection applying a user-defined
// binary predicate mod_lesser
Result3 = set_intersection ( v3a.begin ( ) , v3a.end ( ) ,
v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
cout << "Intersection of source ranges with binary predicate "
<< "mod_lesser specified,\n vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != Result3 ; ++Iter3 )
cout << *Iter3 << " ";
cout << ")." << endl;
}
set_symmetric_difference
將屬於兩個排序來源範圍之一 (但非兩者) 的所有項目聯集為單一排序目的範圍，其中順序準則可由二元述詞指定。
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_symmetric_difference(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
OutputIterator set_symmetric_difference(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result,
BinaryPredicate _Comp );
參數
_First1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，第一個項目的位置，此聯集範圍代表兩個來源範圍的對稱差。
_Last1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，最後一個項目的後面一個位置，此聯集範圍代表兩個來源範圍的對稱差。
_First2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，第一個項目的位置，此聯集範圍代表兩個來源範圍的對稱差。
_Last2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，最後一個項目的後面一個位置，此聯集範圍代表兩個來源範圍的對稱差。
_ 結果
輸出迭代器，用於定址目的範圍中第一個項目的位置，在此目的範圍中，兩個來源範圍會聯集成單一排序範圍，以代表兩個來源範圍的對稱差。
_Comp
使用者定義述詞函式物件，定義一個項目大於另一個項目的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
輸出迭代器，用於定址排序目的範圍中最後一個項目的後面一個位置，此目的範圍代表兩個來源範圍的對稱差。
備註
參考的排序來源範圍必須有效；所有指標都必須可以取值，而且在每個序列中，必須可透過遞增從第一個位置到達最後一個位置。
目的範圍與任何一個來源範圍都不應該重疊，而且大小應該足以包含目的範圍。
每個排序來源範圍必須根據 merge 演算法用來排序結合範圍的相同順序，排列成套用此演算法的前置條件。
這項作業很穩定，因為每個範圍內的項目相對順序會保留在目的範圍中。 演算法 merge 不會修改來源範圍。
輸入迭代器的實值類型必須小於比較才能建立此順序：因此若提供了兩個項目，可以判斷它們相等 (任一個都不小於另一個的意義)，或者一個小於另一個。 這會導致非對等元件之間的排序。 當兩個來源範圍中有對等項目時，目的範圍之第一個來源範圍中的項目會優先於第二個範圍中的項目。 如果來源範圍包含重複的項目，且這些項目在其中一個來源範圍中出現的數目，超過在第二個來源範圍中出現的數目，則目的範圍會包含同時出現之數目的絕對值。
演算法的複雜性為線性最多 2 * (( _Last1 – _First1) – ( _Last2 – _First2)) – 1 非空白的來源範圍的比較。
範例
// alg_set_sym_diff.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1a, v1b, v1 ( 12 );
vector <int>::iterator Iter1a, Iter1b, Iter1, Result1;
// Constructing vectors v1a & v1b with default less-than ordering
int i;
for ( i = -1 ; i <= 4 ; i++ )
{
v1a.push_back( i );
}
int ii;
for ( ii =-3 ; ii <= 0 ; ii++ )
{
v1b.push_back( ii );
}
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vectors v2a & v2b with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
vector <int>::iterator Iter2a, Iter2b, Iter2, Result2;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vectors v3a & v3b with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) , v3 ( v1 );
vector <int>::iterator Iter3a, Iter3b, Iter3, Result3;
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To combine into a symmetric difference in ascending
// order with the default binary predicate less <int> ( )
Result1 = set_symmetric_difference ( v1a.begin ( ) , v1a.end ( ) ,
v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
cout << "Set_symmetric_difference of source ranges with default order,"
<< "\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To combine into a symmetric difference in descending
// order, specify binary predicate greater<int>( )
Result2 = set_symmetric_difference ( v2a.begin ( ) , v2a.end ( ) ,
v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
cout << "Set_symmetric_difference of source ranges with binary"
<< "predicate greater specified,\n vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != Result2 ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// To combine into a symmetric difference applying a user
// defined binary predicate mod_lesser
Result3 = set_symmetric_difference ( v3a.begin ( ) , v3a.end ( ) ,
v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
cout << "Set_symmetric_difference of source ranges with binary "
<< "predicate mod_lesser specified,\n vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != Result3 ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
set_union
將至少屬於兩個排序來源範圍之一的所有項目聯集為單一排序目的範圍，其中順序準則可由二元述詞指定。
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_union(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
OutputIterator set_union(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
InputIterator2Last2,
OutputIterator _Result,
BinaryPredicate _Comp );
參數
_First1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，第一個元素的位置，此聯集範圍代表兩個來源範圍的聯集。
_Last1
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個排序來源範圍的第一個範圍中，最後一個元素的後面一個位置，此聯集範圍代表兩個來源範圍的聯集。
_First2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，第一個元素的位置，此聯集範圍代表兩個來源範圍的聯集。
_Last2
輸入迭代器，用於定址要聯集並排序成單一範圍之兩個連續排序來源範圍的第二個範圍中，最後一個元素的後面一個位置，此聯集範圍代表兩個來源範圍的聯集。
_ 結果
輸出迭代器，用於定址目的範圍中第一個元素的位置，在此目的範圍中，兩個來源範圍會聯集成單一排序範圍，以代表兩個來源範圍的聯集。
_Comp
使用者定義述詞函式物件，定義一個元素大於另一個元素的意義。 此二元述詞接受兩個引數，若第一個項目小於第二個項目，即傳回 true ；否則傳回 false 。
傳回值
輸出迭代器，用於定址排序目的範圍中最後一個元素的後面一個位置，此目的範圍代表兩個來源範圍的聯集。
備註
參考的排序來源範圍必須有效；所有指標都必須可以取值，而且在每個序列中，必須可透過遞增從第一個位置到達最後一個位置。
目的範圍與任何一個來源範圍都不應該重疊，而且大小應該足以包含目的範圍。
每個排序來源範圍必須根據 merge 演算法用來排序結合範圍的相同順序，排列成套用此演算法的前置條件。
這項作業很穩定，因為每個範圍內的元素相對順序會保留在目的範圍中。 演算法 merge不會修改來源範圍。
輸入迭代器的實值類型必須是小於比較才能建立此順序：因此若提供了兩個元素，可以判斷它們相等 (任一個都不小於另一個的意義)，或者一個小於另一個。 這會導致非對等元件之間的排序。 當兩個來源範圍中有對等元素時，目的範圍之第一個來源範圍中的元素會優先於第二個範圍中的元素。 如果來源範圍包含重複的元素，則目的範圍會包含這些元素同時出現在兩個來源範圍中的最大數量元素。
演算法的複雜性為線性最多 2 * (( _Last1 – _First1) – ( _Last2 – _First2)) – 1 的比較。
範例
// alg_set_union.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1a, v1b, v1 ( 12 );
vector <int>::iterator Iter1a, Iter1b, Iter1, Result1;
// Constructing vectors v1a & v1b with default less than ordering
int i;
for ( i = -1 ; i <= 3 ; i++ )
{
v1a.push_back( i );
}
int ii;
for ( ii =-3 ; ii <= 1 ; ii++ )
{
v1b.push_back( ii );
}
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vectors v2a & v2b with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
vector <int>::iterator Iter2a, Iter2b, Iter2, Result2;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vectors v3a & v3b with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) , v3 ( v1 );
vector <int>::iterator Iter3a, Iter3b, Iter3, Result3;
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To combine into a union in ascending order with the default
// binary predicate less <int> ( )
Result1 = set_union ( v1a.begin ( ) , v1a.end ( ) ,
v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
cout << "Union of source ranges with default order,"
<< "\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To combine into a union in descending order, specify binary
// predicate greater<int>( )
Result2 = set_union ( v2a.begin ( ) , v2a.end ( ) ,
v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
cout << "Union of source ranges with binary predicate greater "
<< "specified,\n vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != Result2 ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// To combine into a union applying a user-defined
// binary predicate mod_lesser
Result3 = set_union ( v3a.begin ( ) , v3a.end ( ) ,
v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
cout << "Union of source ranges with binary predicate "
<< "mod_lesser specified,\n vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != Result3 ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
std:: shuffle
使用亂數產生器隨機播放 (重新整理) 指定範圍的元素。
template<class RandomAccessIterator, class UniformRandomNumberGenerator>
void shuffle(RandomAccessIterator first,
RandomAccessIterator last,
UniformRandomNumberGenerator&& gen);
參數
first
範圍中要隨機播放之第一個元素的迭代器，內含。 必須符合 RandomAccessIterator 和 ValueSwappable 的需求。
last
範圍中要隨機播放之最後一個元素的迭代器，專用。 必須符合 RandomAccessIterator 和 ValueSwappable 的需求。
gen
`shuffle()` 函式將用於作業的亂數產生器。 必須符合 `UniformRandomNumberGenerator` 的需求。
備註
如需詳細資訊，以及使用的程式碼範例shuffle()，請參閱<> </> >。
排序
將在指定範圍中的項目排列成非遞減排列，或是依據二元述詞指定的順序準則。
template<class RandomAccessIterator>
void sort(
RandomAccessIterator first,
RandomAccessIterator last
);
template<class RandomAccessIterator, class Predicate>
void sort(
RandomAccessIterator first,
RandomAccessIterator last,
Predicate comp
);
參數
first
隨機存取迭代器，用於定址要排序之範圍中第一個項目的位置。
last
隨機存取迭代器，用於定址要排序之範圍中越過最後一個項目的第一個位置。
comp
使用者定義的述詞函式定義順序中後續項目應符合的比較準則的物件。 此二元述詞會採用兩個引數並傳回true如果兩個引數的順序和false否則。 這個比較子函式必須對序列中項目的配對強制執行嚴格的弱式順序。 如需詳細資訊，請參閱演算法。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
項目是相等的但不是一定是相等，如果沒有小於另。 sort演算法可能會不穩定，因此並不保證會保留對等項目的相對順序。 此演算法stable_sort會保留此原始順序。
The average of a sort complexity is O( N log N), where N = last – first.
範例
// alg_sort.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether first element is greater than the second
bool UDgreater ( int elem1, int elem2 )
{
return elem1 > elem2;
}
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 2 * i );
}
int ii;
for ( ii = 0 ; ii <= 5 ; ii++ )
{
v1.push_back( 2 * ii + 1 );
}
cout << "Original vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
sort( v1.begin( ), v1.end( ) );
cout << "Sorted vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To sort in descending order. specify binary predicate
sort( v1.begin( ), v1.end( ), greater<int>( ) );
cout << "Resorted (greater) vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// A user-defined (UD) binary predicate can also be used
sort( v1.begin( ), v1.end( ), UDgreater );
cout << "Resorted (UDgreater) vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
}
Original vector v1 = ( 0 2 4 6 8 10 1 3 5 7 9 11 )
Sorted vector v1 = ( 0 1 2 3 4 5 6 7 8 9 10 11 )
Resorted (greater) vector v1 = ( 11 10 9 8 7 6 5 4 3 2 1 0 )
Resorted (UDgreater) vector v1 = ( 11 10 9 8 7 6 5 4 3 2 1 0 )
sort_heap
將堆積轉換為排序的範圍。
template<class RandomAccessIterator>
void sort_heap(
RandomAccessIterator _First,
RandomAccessIterator _Last
);
template<class RandomAccessIterator, class Predicate>
void sort_heap(
RandomAccessIterator _First,
RandomAccessIterator _Last,
Predicate _Comp
);
參數
_First
隨機存取迭代器定址目標堆積中的第一個元素的位置。
_Last
隨機存取迭代器定址第一個位置超過目標堆積中的最後一個項目。
_Comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
堆積具有兩個屬性︰
第一個項目一定是最大。
可以加入或移除對數時間項目。
之後如果此演算法、 範圍已套用至應用程式已不再堆積。
由於不一定保留對等項目的相對順序，這是不穩定的排序。
堆積是理想的方式實作優先順序佇列，以及使用標準樣板程式庫容器配接器的實作中priority_queue 類別。
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
The complexity is at most N log N, where N = ( _Last – _First).
範例
// alg_sort_heap.cpp
// compile with: /EHsc
#include <algorithm>
#include <functional>
#include <iostream>
#include <ostream>
#include <string>
#include <vector>
using namespace std;
void print(const string& s, const vector<int>& v) {
cout << s << ": ( ";
for (auto i = v.begin(); i != v.end(); ++i) {
cout << *i << " ";
}
cout << ")" << endl;
}
int main() {
vector<int> v;
for (int i = 1; i <= 9; ++i) {
v.push_back(i);
}
print("Initially", v);
random_shuffle(v.begin(), v.end());
print("After random_shuffle", v);
make_heap(v.begin(), v.end());
print(" After make_heap", v);
sort_heap(v.begin(), v.end());
print(" After sort_heap", v);
random_shuffle(v.begin(), v.end());
print(" After random_shuffle", v);
make_heap(v.begin(), v.end(), greater<int>());
print("After make_heap with greater<int>", v);
sort_heap(v.begin(), v.end(), greater<int>());
print("After sort_heap with greater<int>", v);
}
stable_partition
將範圍中的項目分類為兩個斷續集合，而滿足一元述詞的項目在無法滿足一元述詞的項目之前，保留對等項目的相對順序。
template<class BidirectionalIterator, class Predicate>
BidirectionalIterator stable_partition(
BidirectionalIterator _First,
BidirectionalIteratorLast,
Predicate _Pred );
參數
_First
雙向迭代器定址範圍中的第一個項目的位置進行資料分割。
_Last
雙向迭代器定址超過範圍中最後一個項目的其中一個位置來進行資料分割。
_Pred
使用者定義的述詞函式會定義要分類的項目是否符合條件的物件。 述詞會採用單一引數並傳回true或false。
傳回值
雙向迭代器定址範圍中第一個元素的位置不符合述詞的條件。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
Elements a and b are equivalent, but not necessarily equal, if both Pr ( a, b) is false and Pr ( b, a) if false, where Pr is the parameter-specified predicate. Stable_ 分割演算法穩定，而且保證會保留對等項目的相對順序。 此演算法分割並不一定會保留此原始順序。
範例
// alg_stable_partition.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
bool greater5 ( int value ) {
return value >5;
}
int main( ) {
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2, result;
int i;
for ( i = 0 ; i <= 10 ; i++ )
v1.push_back( i );
int ii;
for ( ii = 0 ; ii <= 4 ; ii++ )
v1.push_back( 5 );
random_shuffle(v1.begin( ), v1.end( ) );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Partition the range with predicate greater10
result = stable_partition (v1.begin( ), v1.end( ), greater5 );
cout << "The partitioned set of elements in v1 is:\n ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "The first element in v1 to fail to satisfy the"
<< "\n predicate greater5 is: " << *result << "." << endl;
}
stable_sort
將在指定範圍中的項目排列成非遞減排列，或是依據二元述詞指定的順序準則，並保留對等項目的相對順序。
template<class BidirectionalIterator>
void stable_sort( BidirectionalIterator _First, BidirectionalIteratorLast );
template<class BidirectionalIterator, class BinaryPredicate>
void stable_sort(
BidirectionalIterator _First,
BidirectionalIteratorLast,
BinaryPredicate _Comp );
參數
_First
雙向迭代器定址範圍中的第一個項目的位置進行排序。
_Last
雙向迭代器定址超過範圍中最後一個項目的其中一個位置來排序。
_Comp
使用者定義的述詞函式定義順序中後續項目應符合的比較準則的物件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
備註
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。
項目是相等的但不是一定是相等，如果沒有小於另。 排序演算法穩定，而且保證會保留對等項目的相對順序。
執行階段複雜度stable_sort取決於可用的記憶體數量是最好的情況下 （要有足夠的記憶體），但O( N記錄N) 最糟的情況，而且O( N (記錄N ) 2)，其中N = _Last – 第一個。 通常，排序演算法速度明顯比stable_sort。
範例
// alg_stable_sort.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether first element is greater than the second
bool UDgreater (int elem1, int elem2 )
{
return elem1 > elem2;
}
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 2 * i );
}
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( 2 * i );
}
cout << "Original vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
stable_sort(v1.begin( ), v1.end( ) );
cout << "Sorted vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To sort in descending order, specify binary predicate
stable_sort(v1.begin( ), v1.end( ), greater<int>( ) );
cout << "Resorted (greater) vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// A user-defined (UD) binary predicate can also be used
stable_sort(v1.begin( ), v1.end( ), UDgreater );
cout << "Resorted (UDgreater) vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
}
Original vector v1 = ( 0 2 4 6 8 10 0 2 4 6 8 10 )
Sorted vector v1 = ( 0 0 2 2 4 4 6 6 8 8 10 10 )
Resorted (greater) vector v1 = ( 10 10 8 8 6 6 4 4 2 2 0 0 )
Resorted (UDgreater) vector v1 = ( 10 10 8 8 6 6 4 4 2 2 0 0 )
交換
第一個覆寫會交換兩個物件的值。 第二個覆寫會交換兩個物件的陣列之間的值。
template<class Type>
void swap(
Type& _Left,
Type& _Right
);
template<class Type, size_t N>
void swap(
Type (& _Left)[N],
Type (& _Right)[N]
);
參數
_Left
針對第一個覆寫時，將其內容交換的第一個物件。 針對第二個覆寫時，將它交換的內容物件的第一個陣列。
_Right
針對第一個覆寫時，將其內容交換的第二個物件。 針對第二個覆寫時，第二個陣列的物件將其內容交換。
備註
第一個多載被為了在個別的物件上作業。 第二個多載會交換兩個陣列之間的物件內容。
範例
// alg_swap.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
int main( )
{
using namespace std;
vector <int> v1, v2;
vector <int>::iterator Iter1, Iter2, result;
for ( int i = 0 ; i <= 10 ; i++ )
{
v1.push_back( i );
}
for ( int ii = 0 ; ii <= 4 ; ii++ )
{
v2.push_back( 5 );
}
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Vector v2 is ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
swap( v1, v2 );
cout << "Vector v1 is ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
cout << "Vector v2 is ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
}
Vector v1 is ( 0 1 2 3 4 5 6 7 8 9 10 ).
Vector v2 is ( 5 5 5 5 5 ).
Vector v1 is ( 5 5 5 5 5 ).
Vector v2 is ( 0 1 2 3 4 5 6 7 8 9 10 ).
swap_ranges
將某個範圍的項目與另一個相等大小之範圍的項目交換。
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges(
ForwardIterator1 _First1,
ForwardIterator1Last1,
ForwardIterator2 _First2 );
參數
_First1
正向迭代器指向其項目要交換的第一個範圍的第一個位置。
_Last1
正向迭代器指向一個超過其項目要交換的第一個範圍的最後一個位置。
_First2
正向迭代器指向其項目要交換的第二個範圍的第一個位置。
傳回值
正向迭代器指向一個超過其項目要交換的第二個範圍的最後一個位置。
備註
參考的範圍必須有效;所有指標都必須都可以取值，而且在每個序列的最後一個位置可以從第可透過遞增。 第二個範圍都必須與第一個範圍一樣大。
複雜性為線性與_Last1– _First1 swap 執行。 如果在相同類型的容器中的項目正在交換，這些swap該容器中的成員函式應該使用，因為成員函式通常會有常數複雜度。
範例
// alg_swap_ranges.cpp
// compile with: /EHsc
#include <vector>
#include <deque>
#include <algorithm>
#include <iostream>
int main( )
{
using namespace std;
vector <int> v1;
deque <int> d1;
vector <int>::iterator v1Iter1;
deque<int>::iterator d1Iter1;
int i;
for ( i = 0 ; i <= 5 ; i++ )
{
v1.push_back( i );
}
int ii;
for ( ii =4 ; ii <= 9 ; ii++ )
{
d1.push_back( 6 );
}
cout << "Vector v1 is ( " ;
for ( v1Iter1 = v1.begin( ) ; v1Iter1 != v1.end( ) ;v1Iter1 ++ )
cout << *v1Iter1 << " ";
cout << ")." << endl;
cout << "Deque d1 is ( " ;
for ( d1Iter1 = d1.begin( ) ; d1Iter1 != d1.end( ) ;d1Iter1 ++ )
cout << *d1Iter1 << " ";
cout << ")." << endl;
swap_ranges ( v1.begin ( ) , v1.end ( ) , d1.begin ( ) );
cout << "After the swap_range, vector v1 is ( " ;
for ( v1Iter1 = v1.begin( ) ; v1Iter1 != v1.end( ) ;v1Iter1 ++ )
cout << *v1Iter1 << " ";
cout << ")." << endl;
cout << "After the swap_range deque d1 is ( " ;
for ( d1Iter1 = d1.begin( ) ; d1Iter1 != d1.end( ) ;d1Iter1 ++ )
cout << *d1Iter1 << " ";
cout << ")." << endl;
}
Vector v1 is ( 0 1 2 3 4 5 ).
Deque d1 is ( 6 6 6 6 6 6 ).
After the swap_range, vector v1 is ( 6 6 6 6 6 6 ).
After the swap_range deque d1 is ( 0 1 2 3 4 5 ).
轉換
將指定的函式物件應用至來源範圍中的每個項目，或是一組來自兩個來源範圍的項目，並複製函式物件的傳回值到目的範圍。
template<class InputIterator, class OutputIterator, class UnaryFunction>
OutputIterator transform(
InputIterator _First1,
InputIterator _Last1,
OutputIterator _Result,
UnaryFunction _Func );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryFunction>
OutputIterator transform(
InputIterator1 _First1,
InputIterator1Last1,
InputIterator2 _First2,
OutputIterator _Result,
BinaryFunction _Func );
參數
_First1
輸入迭代器定址要操作的第一個來源範圍中第一個項目的位置。
_Last1
輸入迭代器定址超過第一個來源範圍中最後一個項目的其中一個位置上操作。
_First2
輸入迭代器，用於定址第二個來源範圍中要執行之第一個項目的位置。
_Result
輸出迭代器，用於定址目的範圍中第一個項目的位置。
_Func
演算法套用至每個項目，第一個來源範圍中的第一個版本中所用的使用者定義一元函式物件或使用者定義 (UD) 的二元函式物件的兩個來源範圍的正向順序成對套用演算法的第二個版本中使用。
傳回值
輸出迭代器，用於定址超過接收函式物件所轉換之輸出項目的目的範圍中最後一個項目的第一個位置。
備註
參考的範圍必須有效;所有指標必須都可以取值，而且在每個序列的最後一個位置必須都可從第一個可透過遞增。 目標範圍必須夠大，無法包含已轉換的來源範圍。
如果_Result設為等於_First1演算法的第一版*，*則來源和目的範圍將會相同，並會就地修改序列。 但是_Result可能無法解決的範圍內的位置 [ _First1 + 1， _Last1)。
複雜性為線性與最多 ( _Last1 – _First1) 比較。
範例
// alg_transform.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
// The function object multiplies an element by a Factor
template <class Type>
class MultValue
{
private:
Type Factor; // The value to multiply by
public:
// Constructor initializes the value to multiply by
MultValue ( const Type& _Val ) : Factor ( _Val ) {
}
// The function call for the element to be multiplied
Type operator ( ) ( Type& elem ) const
{
return elem * Factor;
}
};
int main( )
{
using namespace std;
vector <int> v1, v2 ( 7 ), v3 ( 7 );
vector <int>::iterator Iter1, Iter2 , Iter3;
// Constructing vector v1
int i;
for ( i = -4 ; i <= 2 ; i++ )
{
v1.push_back( i );
}
cout << "Original vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Modifying the vector v1 in place
transform (v1.begin ( ) , v1.end ( ) , v1.begin ( ) , MultValue<int> ( 2 ) );
cout << "The elements of the vector v1 multiplied by 2 in place gives:"
<< "\n v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Using transform to multiply each element by a factor of 5
transform ( v1.begin ( ) , v1.end ( ) , v2.begin ( ) , MultValue<int> ( 5 ) );
cout << "Multiplying the elements of the vector v1mod\n "
<< "by the factor 5 & copying to v2 gives:\n v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// The second version of transform used to multiply the
// elements of the vectors v1mod & v2 pairwise
transform ( v1.begin ( ) , v1.end ( ) , v2.begin ( ) , v3.begin ( ) ,
multiplies <int> ( ) );
cout << "Multiplying elements of the vectors v1mod and v2 pairwise "
<< "gives:\n v3 = ( " ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
Original vector v1 = ( -4 -3 -2 -1 0 1 2 ).
The elements of the vector v1 multiplied by 2 in place gives:
v1mod = ( -8 -6 -4 -2 0 2 4 ).
Multiplying the elements of the vector v1mod
by the factor 5 & copying to v2 gives:
v2 = ( -40 -30 -20 -10 0 10 20 ).
Multiplying elements of the vectors v1mod and v2 pairwise gives:
v3 = ( 320 180 80 20 0 20 80 ).
唯一
移除在指定範圍內彼此相鄰的重複項目。
template<class ForwardIterator>
ForwardIterator unique(
ForwardIterator _First,
ForwardIterator _Last
);
template<class ForwardIterator, class Predicate>
ForwardIterator unique(
ForwardIterator _First,
ForwardIterator _Last,
Predicate _Comp
);
參數
_First
正向迭代器定址掃描移除重複項目範圍中的第一個項目的位置。
_Last
正向迭代器定址超過一個位置的最終項目範圍中要掃描的移除重複項目。
_Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器已修改的序列，其中包含沒有連續重複項目的新結尾一個不會移除的最後一個元素之後的位置。
備註
這兩種形式的演算法都會從一對連續的相等項目中，移除第二個重複項目。
此演算法作業很穩定，因此不會變更未刪除項目的相對順序。
參考的範圍必須有效；所有指標都必須可以取值，而且在序列中，可透過遞增從第一個位置到達最後一個位置。 演算法不會變更數字序列中項目的他唯一和已修改的序列結尾之外的項目是可取值，但未指定。
複雜性為線性要求 ( _Last – _First) – 1 的比較。
清單提供更有效率的成員函式 「 唯一 」，這可能會更好。
這些演算法不能在關聯的容器。
範例
// alg_unique.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
#include <ostream>
using namespace std;
// Return whether modulus of elem1 is equal to modulus of elem2
bool mod_equal ( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 == elem2;
};
int main( )
{
vector <int> v1;
vector <int>::iterator v1_Iter1, v1_Iter2, v1_Iter3,
v1_NewEnd1, v1_NewEnd2, v1_NewEnd3;
int i;
for ( i = 0 ; i <= 3 ; i++ )
{
v1.push_back( 5 );
v1.push_back( -5 );
}
int ii;
for ( ii = 0 ; ii <= 3 ; ii++ )
{
v1.push_back( 4 );
}
v1.push_back( 7 );
cout << "Vector v1 is ( " ;
for ( v1_Iter1 = v1.begin( ) ; v1_Iter1 != v1.end( ) ; v1_Iter1++ )
cout << *v1_Iter1 << " ";
cout << ")." << endl;
// Remove consecutive duplicates
v1_NewEnd1 = unique ( v1.begin ( ) , v1.end ( ) );
cout << "Removing adjacent duplicates from vector v1 gives\n ( " ;
for ( v1_Iter1 = v1.begin( ) ; v1_Iter1 != v1_NewEnd1 ; v1_Iter1++ )
cout << *v1_Iter1 << " ";
cout << ")." << endl;
// Remove consecutive duplicates under the binary prediate mod_equals
v1_NewEnd2 = unique ( v1.begin ( ) , v1_NewEnd1 , mod_equal );
cout << "Removing adjacent duplicates from vector v1 under the\n "
<< " binary predicate mod_equal gives\n ( " ;
for ( v1_Iter2 = v1.begin( ) ; v1_Iter2 != v1_NewEnd2 ; v1_Iter2++ )
cout << *v1_Iter2 << " ";
cout << ")." << endl;
// Remove elements if preceded by an element that was greater
v1_NewEnd3 = unique ( v1.begin ( ) , v1_NewEnd2, greater<int>( ) );
cout << "Removing adjacent elements satisfying the binary\n "
<< " predicate mod_equal from vector v1 gives ( " ;
for ( v1_Iter3 = v1.begin( ) ; v1_Iter3 != v1_NewEnd3 ; v1_Iter3++ )
cout << *v1_Iter3 << " ";
cout << ")." << endl;
}
Vector v1 is ( 5 -5 5 -5 5 -5 5 -5 4 4 4 4 7 ).
Removing adjacent duplicates from vector v1 gives
( 5 -5 5 -5 5 -5 5 -5 4 7 ).
Removing adjacent duplicates from vector v1 under the
binary predicate mod_equal gives
( 5 4 7 ).
Removing adjacent elements satisfying the binary
predicate mod_equal from vector v1 gives ( 5 7 ).
unique_copy
將來源範圍的項目複製到目的範圍，但是彼此相鄰的重複項目除外。
template<class InputIterator, class OutputIterator>
OutputIterator unique_copy( InputIterator _First,
InputIterator _Last,
OutputIterator _Result );
template<class InputIterator, class OutputIterator, class BinaryPredicate>
OutputIterator unique_copy( InputIterator _First,
InputIterator _Last,
OutputIterator _Result,
BinaryPredicate _Comp );
參數
_First
正向迭代器，用於定址要複製之來源範圍中第一個項目的位置。
_Last
正向迭代器，用於定址要複製之來源範圍中最後一個項目的後面一個位置。
_Result
輸出迭代器，用於定址正在接收所移除的連續重複項目複本之目的範圍中，第一個項目的位置。
_Comp
使用者定義的述詞函式物件，定義要接受兩個元素為對等時所要符合的條件。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
輸出迭代器，用於定址正在接收所移除的連續重複項目複本之目的範圍中，最後一個項目的後面一個位置。
備註
這兩種形式的演算法都會從一對連續的相等項目中，移除第二個重複項目。
此演算法作業很穩定，因此不會變更未刪除項目的相對順序。
參考的範圍必須有效；所有指標都必須可以取值，而且在一個序列中，可透過遞增從第一個位置到達最後一個位置。
複雜性為線性要求 ( _Last – _First) 比較。
範例
// alg_unique_copy.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
#include <ostream>
using namespace std;
// Return whether modulus of elem1 is equal to modulus of elem2
bool mod_equal ( int elem1, int elem2 ) {
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 == elem2;
};
int main() {
vector <int> v1;
vector <int>::iterator v1_Iter1, v1_Iter2,
v1_NewEnd1, v1_NewEnd2;
int i;
for ( i = 0 ; i <= 1 ; i++ ) {
v1.push_back( 5 );
v1.push_back( -5 );
}
int ii;
for ( ii = 0 ; ii <= 2 ; ii++ )
v1.push_back( 4 );
v1.push_back( 7 );
int iii;
for ( iii = 0 ; iii <= 5 ; iii++ )
v1.push_back( 10 );
cout << "Vector v1 is\n ( " ;
for ( v1_Iter1 = v1.begin( ) ; v1_Iter1 != v1.end( ) ; v1_Iter1++ )
cout << *v1_Iter1 << " ";
cout << ")." << endl;
// Copy first half to second, removing consecutive duplicates
v1_NewEnd1 = unique_copy ( v1.begin ( ) , v1.begin ( ) + 8, v1.begin ( ) + 8 );
cout << "Copying the first half of the vector to the second half\n "
<< "while removing adjacent duplicates gives\n ( " ;
for ( v1_Iter1 = v1.begin( ) ; v1_Iter1 != v1_NewEnd1 ; v1_Iter1++ )
cout << *v1_Iter1 << " ";
cout << ")." << endl;
int iv;
for ( iv = 0 ; iv <= 7 ; iv++ )
v1.push_back( 10 );
// Remove consecutive duplicates under the binary prediate mod_equals
v1_NewEnd2 = unique_copy ( v1.begin ( ) , v1.begin ( ) + 14,
v1.begin ( ) + 14 , mod_equal );
cout << "Copying the first half of the vector to the second half\n "
<< " removing adjacent duplicates under mod_equals gives\n ( " ;
for ( v1_Iter2 = v1.begin( ) ; v1_Iter2 != v1_NewEnd2 ; v1_Iter2++ )
cout << *v1_Iter2 << " ";
cout << ")." << endl;
}
upper_bound
在已排序範圍中尋找值大於指定值的第一個項目的位置，其中順序準則可由二元述詞指定。
template<class ForwardIterator, class Type>
ForwardIterator upper_bound(
ForwardIterator first,
ForwardIterator last,
const Type& value
);
template<class ForwardIterator, class Type, class Predicate>
ForwardIterator upper_bound(
ForwardIterator first,
ForwardIterator last,
const Type& value,
Predicate comp
);
參數
first
要搜尋範圍中第一個項目的位置。
last
一個之後的位置的最終項目中要搜尋的範圍。
value
需要超過所傳回的迭代器定址的項目值的已排序範圍中的值。
comp
使用者定義的述詞函式物件，定義在其中一個項目小於另一個的意義。 二元述詞會採用兩個引數，並且在符合時傳回 true ，不符合時則傳回 false 。
傳回值
正向迭代器的值大於指定值的第一個元素的位置。
備註
參考的排序的來源範圍必須有效;所有迭代器必須可以取值，而且在序列中最後一個位置必須可從第一個可透過遞增。
已排序的範圍是使用的前置條件upper_bound和其中的順序準則是二元述詞所指定的值相同。
範圍不會修改upper_bound。
正向迭代器的實值型別必須是小於-比比較排序，以便提供兩個項目，可以判斷它們相等 （中都不小於另的意義） 或是其中一個是小於另。 這會導致非對等元件之間的排序
演算法的複雜度是對數隨機存取迭代器和線性比例的步驟數目與否則 ( last - first)。
範例
// alg_upper_bound.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser( int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector<int> v1;
// Constructing vector v1 with default less-than ordering
for ( auto i = -1 ; i <= 4 ; ++i )
{
v1.push_back( i );
}
for ( auto ii =-3 ; ii <= 0 ; ++ii )
{
v1.push_back( ii );
}
cout << "Starting vector v1 = ( " ;
for (const auto &Iter : v1)
cout << Iter << " ";
cout << ")." << endl;
sort(v1.begin(), v1.end());
cout << "Original vector v1 with range sorted by the\n "
<< "binary predicate less than is v1 = ( " ;
for (const auto &Iter : v1)
cout << Iter << " ";
cout << ")." << endl;
// Constructing vector v2 with range sorted by greater
vector<int> v2(v1);
sort(v2.begin(), v2.end(), greater<int>());
cout << "Original vector v2 with range sorted by the\n "
<< "binary predicate greater is v2 = ( " ;
for (const auto &Iter : v2)
cout << Iter << " ";
cout << ")." << endl;
// Constructing vectors v3 with range sorted by mod_lesser
vector<int> v3(v1);
sort(v3.begin(), v3.end(), mod_lesser);
cout << "Original vector v3 with range sorted by the\n "
<< "binary predicate mod_lesser is v3 = ( " ;
for (const auto &Iter : v3)
cout << Iter << " ";
cout << ")." << endl;
// Demonstrate upper_bound
vector<int>::iterator Result;
// upper_bound of 3 in v1 with default binary predicate less<int>()
Result = upper_bound(v1.begin(), v1.end(), 3);
cout << "The upper_bound in v1 for the element with a value of 3 is: "
<< *Result << "." << endl;
// upper_bound of 3 in v2 with the binary predicate greater<int>( )
Result = upper_bound(v2.begin(), v2.end(), 3, greater<int>());
cout << "The upper_bound in v2 for the element with a value of 3 is: "
<< *Result << "." << endl;
// upper_bound of 3 in v3 with the binary predicate mod_lesser
Result = upper_bound(v3.begin(), v3.end(), 3, mod_lesser);
cout << "The upper_bound in v3 for the element with a value of 3 is: "
<< *Result << "." << endl;
}