Fungsi <algorithm>

Header <algorithm> menyediakan fungsi berikut:

adjacent_find

Mencari dua elemen yang berdekatan yang sama atau memenuhi kondisi yang ditentukan.

template<class ForwardIterator>
ForwardIterator adjacent_find(
    ForwardIterator first,
    ForwardIterator last);

template<class ForwardIterator , class BinaryPredicate>
ForwardIterator adjacent_find(
    ForwardIterator first,
    ForwardIterator last,
    BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator adjacent_find(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
ForwardIterator adjacent_find(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    BinaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan pada posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator maju pada posisi satu melewati elemen akhir dalam rentang yang akan dicari.

pred
Predikat biner yang memberikan kondisi untuk dipenuhi oleh nilai elemen yang berdekatan dalam rentang yang sedang dicari.

Nilai hasil

Iterator penerusan ke elemen pertama yang berdekatan yang sama satu sama lain (dalam versi pertama) atau yang memenuhi kondisi yang diberikan oleh predikat biner (di versi kedua) jika sepasang elemen tersebut ditemukan. Jika tidak, iterator yang menunjuk ke last dikembalikan.

Keterangan

adjacent_find Algoritma adalah algoritma urutan nonmutasi. Rentang yang akan dicari harus valid. Semua pointer harus dapat didereferensikan, dan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi. Kompleksitas waktu algoritma linier dalam jumlah elemen yang terkandung dalam rentang.

yang operator== digunakan untuk menentukan kecocokan antar elemen harus memaksakan hubungan kesetaraan antara operannya.

Contoh

// 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++)
            << " & " << *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

Mengembalikan true saat kondisi ada di setiap elemen dalam rentang yang diberikan.

template<class InputIterator, class UnaryPredicate>
bool all_of(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template <class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
bool all_of(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan tempat untuk mulai memeriksa kondisi. Iterator menandai di mana rentang elemen dimulai.

last
Iterator input yang menunjukkan akhir rentang elemen untuk memeriksa kondisi.

pred
Kondisi untuk diuji. pred adalah objek fungsi predikat unary yang ditentukan pengguna yang menentukan kondisi yang harus dipenuhi oleh elemen yang sedang diperiksa. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

Mengembalikan true jika kondisi terdeteksi pada setiap elemen dalam rentang yang ditunjukkan atau jika rentang kosong, dan false sebaliknya.

Keterangan

Fungsi templat hanya mengembalikan true jika, untuk masing-masing N dalam rentang [0, last - first), predikatnya pred(*(first + N)) adalah true.

Contoh

// alg_all_of.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>

int main()
{
    using namespace std;

    list<int> li { 50, 40, 10, 20, 20 };
    list<int>::iterator iter;

    cout << "li = ( ";
    for (iter = li.begin(); iter != li.end(); iter++)
        cout << *iter << " ";
    cout << ")" << endl;

    // Check if all elements in li are even.
    auto is_even = [](int elem){ return !(elem % 2); };
    if (all_of(li.begin(), li.end(), is_even))
        cout << "All the elements are even numbers.\n";
    else
        cout << "Not all the elements are even numbers.\n";
}

li = ( 50 40 10 20 20 )
All the elements are even numbers.

any_of

true Mengembalikan saat kondisi ada setidaknya sekali dalam rentang elemen yang ditentukan.

template<class InputIterator, class UnaryPredicate>
bool any_of(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template <class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
bool any_of(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan tempat untuk mulai memeriksa berbagai elemen untuk kondisi.

last
Iterator input yang menunjukkan akhir rentang elemen untuk memeriksa kondisi.

pred
Kondisi untuk diuji. Pengujian ini disediakan oleh objek fungsi predikat yang ditentukan pengguna. Predikat mendefinisikan kondisi yang harus dipenuhi oleh elemen yang sedang diuji. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

Mengembalikan true jika kondisi terdeteksi setidaknya sekali dalam rentang yang ditunjukkan, false jika kondisi tidak pernah terdeteksi.

Keterangan

Fungsi templat hanya mengembalikan true jika, untuk beberapa N dalam rentang

[0, last - first), predikatnya pred(*(first + N)) benar.

Contoh

// alg_any_of.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>

int main()
{
    using namespace std;

    list<int> li { 51, 41, 11, 21, 20 };

    cout << "li = ( ";
    for (auto const& el : li)
        cout << el << " ";
    cout << ")" << endl;

    // Check if there's an even element in li.
    auto is_even = [](int const elem){ return !(elem % 2); };
    if (any_of(li.begin(), li.end(), is_even))
        cout << "There's an even element in li.\n";
    else
        cout << "There are no even elements in li.\n";
}

li = ( 51 41 11 21 20 )
There's an even element in li.

binary_search

Menguji apakah ada elemen dalam rentang yang diurutkan yang sama dengan nilai tertentu atau yang setara dengan elemen tersebut dalam arti yang ditentukan oleh predikat biner.

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 pred);

Parameter

first
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

value
Nilai yang diperlukan untuk dicocokkan dengan nilai elemen atau yang harus memenuhi kondisi dengan nilai elemen yang ditentukan oleh predikat biner.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

true jika elemen ditemukan dalam rentang yang sama atau setara dengan nilai yang ditentukan; jika tidak, false.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan, dalam urutan, posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi binary_search algoritma sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Rentang sumber tidak dimodifikasi oleh binary_search.

Jenis nilai iterator penerusan harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara.

Kompleksitas algoritma adalah logaritma untuk iterator akses acak dan linear jika tidak, dengan jumlah langkah yang proporsional dengan (last-first).

Contoh

// 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;
}

List1 = ( 5 10 20 25 30 50 )
There is an element in list List1 with a value equal to 10.
There is an element in list List1 with a value greater than 10 under greater than.
Ordered using mod_lesser, vector v1 = ( 0 -1 1 -2 2 3 4 )
There is an element with a value equivalent to -3 under mod_lesser.

clamp

Membandingkan nilai dengan batas atas dan bawah, dan mengembalikan referensi ke nilai jika berada di antara batas, atau referensi ke batas atas atau bawah jika nilai berada di atas atau di bawahnya, masing-masing.

template<class Type>
constexpr const Type& clamp(
    const Type& value,
    const Type& lower,
    const Type& upper);

template<class Type, class Compare>
constexpr const Type& clamp(
    const Type& value,
    const Type& lower,
    const Type& upper,
    Compare pred);

Parameter

value
Nilai untuk dibandingkan dengan upper dan lower.

lower
Batas bawah nilai untuk dijepit value .

upper
Batas atas nilai untuk dijepit value .

pred
Predikat yang digunakan untuk membandingkan value dengan lower atau upper. Predikat perbandingan mengambil dua argumen dan mengembalikan true jika yang pertama dalam arti tertentu kurang dari yang kedua, dan jika tidak, false.

Nilai hasil

Mengembalikan referensi ke lower jika value < lower, atau referensi ke upper jika upper < value. Jika tidak, ia mengembalikan referensi ke value.

Keterangan

Perilaku tidak ditentukan jika upper kurang dari lower.

copy

Menetapkan nilai elemen dari rentang sumber ke rentang tujuan, mengulangi urutan sumber elemen dan menetapkannya posisi baru ke arah depan.

template<class InputIterator, class OutputIterator>
OutputIterator copy(
    InputIterator first,
    InputIterator last,
    OutputIterator destBeg);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 copy(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas posisi elemen pertama dalam rentang sumber.

last
Iterator input yang membahas posisi yang melewati elemen akhir dalam rentang sumber.

destBeg
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan.

Nilai hasil

Iterator output yang membahas posisi yang melewati elemen akhir dalam rentang tujuan, yaitu, alamat result iterator + (last - first).

Keterangan

Rentang sumber harus valid dan harus ada cukup ruang di tujuan untuk menahan semua elemen yang sedang disalin.

Karena algoritma menyalin elemen sumber secara berurutan dimulai dengan elemen pertama, rentang tujuan dapat tumpang tindih dengan rentang sumber asalkan last posisi rentang sumber tidak terkandung dalam rentang tujuan. copy dapat digunakan untuk menggeser elemen ke kiri tetapi bukan kanan, kecuali tidak ada tumpang tindih antara rentang sumber dan tujuan. Untuk bergeser ke kanan sejumlah posisi, gunakan copy_backward algoritma.

copy Algoritma hanya memodifikasi nilai yang ditujukan oleh iterator, menetapkan nilai baru ke elemen dalam rentang tujuan. Ini tidak dapat digunakan untuk membuat elemen baru dan tidak dapat menyisipkan elemen ke dalam kontainer kosong secara langsung.

Contoh

// 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;
}

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

Menetapkan nilai elemen dari rentang sumber ke rentang tujuan, melakukan iterasi melalui urutan sumber elemen dan menetapkannya posisi baru ke arah mundur.

template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward(
    BidirectionalIterator1 first,
    BidirectionalIterator1 last,
    BidirectionalIterator2 destEnd);

Parameter

first
Iterator dua arah yang membahas posisi elemen pertama dalam rentang sumber.

last
Iterator dua arah yang membahas posisi yang melewati elemen akhir dalam rentang sumber.

destEnd
Iterator dua arah yang membahas posisi satu melewati elemen akhir dalam rentang tujuan.

Nilai hasil

Iterator output yang membahas posisi yang melewati elemen akhir dalam rentang tujuan, yaitu, iterator membahas destEnd - (last - first).

Keterangan

Rentang sumber harus valid dan harus ada cukup ruang di tujuan untuk menahan semua elemen yang sedang disalin.

copy_backward Algoritma memberlakukan persyaratan yang copy lebih ketat daripada algoritma. Iterator input dan outputnya harus dua arah.

copy_backward Algoritma dan move_backward adalah satu-satunya algoritma Pustaka Standar C++ yang menunjuk rentang output dengan iterator yang menunjuk ke akhir rentang tujuan.

Karena algoritma menyalin elemen sumber secara berurutan dimulai dengan elemen terakhir, rentang tujuan dapat tumpang tindih dengan rentang sumber asalkan first posisi rentang sumber tidak terkandung dalam rentang tujuan. copy_backward dapat digunakan untuk menggeser elemen ke kanan tetapi bukan kiri, kecuali tidak ada tumpang tindih antara rentang sumber dan tujuan. Untuk bergeser ke kiri sejumlah posisi, gunakan copy algoritma.

copy_backward Algoritma hanya memodifikasi nilai yang ditujukan oleh iterator, menetapkan nilai baru ke elemen dalam rentang tujuan. Ini tidak dapat digunakan untuk membuat elemen baru dan tidak dapat menyisipkan elemen ke dalam kontainer kosong secara langsung.

Contoh

// 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;
}

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 6 9 0 10 0 10 20 27 30 )

copy_if

Dalam berbagai elemen, salin elemen yang untuk true kondisi yang ditentukan.

template<class InputIterator, class OutputIterator, class UnaryPredicate>
OutputIterator copy_if(
    InputIterator first,
    InputIterator last,
    OutputIterator dest,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class UnaryPredicate>
ForwardIterator2 copy_if(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan awal rentang untuk memeriksa kondisi.

last
Iterator input yang menunjukkan akhir rentang.

dest
Iterator output yang menunjukkan tujuan untuk elemen yang disalin.

pred
Kondisi di mana setiap elemen dalam rentang diuji. Kondisi ini disediakan oleh objek fungsi predikat yang ditentukan pengguna. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

Iterator output yang sama dengan dest bertahap sekali untuk setiap elemen yang memenuhi kondisi. Dengan kata lain, nilai pengembalian dikurangi dest sama dengan jumlah elemen yang disalin.

Keterangan

Fungsi templat mengevaluasi

if (pred(*first + N)) * dest++ = *(first + N))

sekali untuk masing-masing N dalam rentang [0, last - first), untuk meningkatkan nilai N yang benar-benar dimulai dengan nilai terendah. Jika dest dan first menunjuk wilayah penyimpanan, dest tidak boleh berada dalam rentang [ first, last ).

Contoh

// alg_copy_if.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>

void listlist(std::list<int> l)
{
    std::cout << "( ";
    for (auto const& el : l)
        std::cout << el << " ";
    std::cout << ")" << std::endl;
}

int main()
{
    using namespace std;
    list<int> li{ 46, 59, 88, 72, 79, 71, 60, 5, 40, 84 };
    list<int> le(li.size()); // le = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    list<int> lo(li.size()); // lo = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    cout << "li = ";
    listlist(li);

    // is_even checks if the element is even.
    auto is_even = [](int const elem) { return !(elem % 2); };
    // use copy_if to select only even elements from li
    // and copy them to le, starting from le's begin position
    auto ec = copy_if(li.begin(),li.end(), le.begin(), is_even);
    le.resize(std::distance(le.begin(), ec));  // shrink le to new size

    cout << "Even numbers are le = ";
    listlist(le);

    // is_odd checks if the element is odd.
    auto is_odd = [](int const elem) { return (elem % 2); };
    // use copy_if to select only odd elements from li
    // and copy them to lo, starting from lo's begin position
    auto oc = copy_if(li.begin(), li.end(), lo.begin(), is_odd);
    lo.resize(std::distance(lo.begin(), oc));  // shrink lo to new size

    cout << "Odd numbers are lo = ";
    listlist(lo);
}

li = ( 46 59 88 72 79 71 60 5 40 84 )
Even numbers are le = ( 46 88 72 60 40 84 )
Odd numbers are lo = ( 59 79 71 5 )

copy_n

Menyalin sejumlah elemen tertentu.

template<class InputIterator, class Size, class OutputIterator>
OutputIterator copy_n(
    InputIterator first,
    Size count,
    OutputIterator dest);

template<class ExecutionPolicy, class ForwardIterator1, class Size, class ForwardIterator2>
ForwardIterator2 copy_n(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    Size count,
    ForwardIterator2 dest);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan dari mana harus menyalin elemen.

count
Jenis bilangan bulat yang ditandatangani atau tidak ditandatangani yang menentukan jumlah elemen yang akan disalin.

dest
Iterator output yang menunjukkan tempat menyalin elemen.

Nilai hasil

Mengembalikan iterator output tempat elemen telah disalin. Ini sama dengan nilai parameter yang dest dikembalikan.

Keterangan

Fungsi templat mengevaluasi *(dest + N) = *(first + N)) sekali untuk masing-masing N dalam rentang [0, count), untuk meningkatkan nilai N yang benar-benar dimulai dengan nilai terendah. Kemudian mengembalikan dest + N. Jika dest dan first menunjuk wilayah penyimpanan, dest tidak boleh berada dalam rentang [first, last).

Contoh

// alg_copy_n.cpp
// compile with: cl /EHsc /W4 alg_copy_n.cpp
#include <algorithm>
#include <iostream>
#include <string>

int main()
{
    using namespace std;
    string s1{"dandelion"};
    string s2{"badger"};

    cout << s1 << " + " << s2 << " = ";

    // Copy the first 3 letters from s1
    // to the first 3 positions in s2
    copy_n(s1.begin(), 3, s2.begin());

    cout << s2 << endl;
}

dandelion + badger = danger

count

Mengembalikan jumlah elemen dalam rentang yang nilainya cocok dengan nilai tertentu.

template<class InputIterator, class Type>
typename iterator_traits<InputIterator>::difference_type count(
    InputIterator first,
    InputIterator last,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class Type>
typename iterator_traits<ForwardIterator>::difference_type
count(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas posisi elemen pertama dalam rentang yang akan dilalui.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dilalui.

value
Nilai elemen yang akan dihitung.

Nilai hasil

Jenis perbedaan yang InputIterator menghitung jumlah elemen dalam rentang [first, last) yang memiliki nilai value.

Keterangan

yang operator== digunakan untuk menentukan kecocokan antara elemen dan nilai yang ditentukan harus memaksakan hubungan kesetaraan antara operannya.

Algoritma ini digeneralisasi untuk menghitung elemen yang memenuhi predikat apa pun dengan fungsi count_iftemplat .

Contoh

// 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

Mengembalikan jumlah elemen dalam rentang yang nilainya memenuhi kondisi tertentu.

template<class InputIterator, class UnaryPredicate>
typename iterator_traits<InputIterator>::difference_type count_if(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
typename iterator_traits<ForwardIterator>::difference_type
count_if(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika elemen akan dihitung. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

Jumlah elemen yang memenuhi kondisi yang ditentukan oleh predikat.

Keterangan

Fungsi templat ini adalah generalisasi algoritma count, mengganti predikat "sama dengan nilai tertentu" dengan predikat apa pun.

Contoh

// 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.

equal

Membandingkan dua rentang elemen berdasarkan elemen untuk kesetaraan atau kesetaraan dalam arti yang ditentukan oleh predikat biner.

Gunakan std::equal saat membandingkan elemen dalam jenis kontainer yang berbeda (misalnya vector dan list) atau saat membandingkan jenis elemen yang berbeda, atau ketika Anda perlu membandingkan subranges kontainer. Jika tidak, saat membandingkan elemen dengan jenis yang sama dalam jenis kontainer yang sama, gunakan non-anggota operator== yang disediakan untuk setiap kontainer.

Gunakan kelebihan beban rentang ganda dalam kode C++14 karena kelebihan beban yang hanya mengambil satu iterator untuk rentang kedua tidak akan mendeteksi perbedaan jika rentang kedua lebih panjang dari rentang pertama. Kelebihan beban ini akan mengakibatkan perilaku yang tidak ditentukan jika rentang kedua lebih pendek dari rentang pertama.

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 pred); // 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 pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool equal(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
bool equal(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool equal(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
bool equal(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama dalam rentang pertama yang akan diuji.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir dalam rentang pertama yang akan diuji.

first2
Iterator input yang membahas posisi elemen pertama dalam rentang kedua yang akan diuji.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam rentang kedua yang akan diuji.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

true jika dan hanya jika rentang identik atau setara dengan predikat biner jika dibandingkan dengan elemen; jika tidak, false.

Keterangan

Rentang yang akan dicari harus valid; semua iterator harus dapat didereferensikan dan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Jika kedua rentang memiliki panjang yang sama, maka kompleksitas waktu algoritma bersifat linier dalam jumlah elemen yang terkandung dalam rentang. Jika tidak, fungsi segera mengembalikan false.

Anda tidak memerlukan operator== atau predikat yang ditentukan pengguna untuk memaksakan hubungan kesetaraan yang simetris, refleksif, dan transitif di antara operannya.

Contoh

#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;
}

v1 and v2 are equal: 1
v1 and v3 are equal: 1
v1 and v3 are equal with dual-range overload: 0

equal_range

Mengingat rentang yang diurutkan, menemukan subrange di mana semua elemen setara dengan nilai tertentu.

template<class ForwardIterator, class Type>
pair<ForwardIterator, ForwardIterator> equal_range(
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

template<class ForwardIterator, class Type, class Compare>
pair<ForwardIterator, ForwardIterator> equal_range(
    ForwardIterator first,
    ForwardIterator last,
    const Type& value,
    Compare pred);

Parameter

first
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

value
Nilai yang sedang dicari dalam rentang yang diurutkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Sepasang iterator penerusan yang menentukan subrange, yang terkandung dalam rentang yang dicari, di mana semua elemen setara value dengan dalam arti yang ditentukan oleh predikat biner yang digunakan (baik pred atau default, kurang dari).

Jika tidak ada elemen dalam rentang yang setara dengan value, iterator penerusan dalam pasangan yang dikembalikan sama dan tentukan titik di mana value dapat disisipkan tanpa mengganggu urutan rentang.

Keterangan

Iterator pertama pasangan yang dikembalikan oleh algoritma adalah lower_bound, dan iterator kedua adalah upper_bound.

Rentang harus diurutkan sesuai dengan predikat yang disediakan untuk equal_range. Misalnya, jika Anda akan menggunakan predikat yang lebih besar dari, rentang harus diurutkan dalam urutan turun.

Elemen dalam subrange yang mungkin kosong yang ditentukan oleh pasangan iterator yang dikembalikan oleh akan setara dengan equal_range nilai dalam arti yang ditentukan oleh predikat yang digunakan.

Kompleksitas algoritma adalah logaritma untuk iterator akses acak dan linear jika tidak, dengan jumlah langkah yang proporsional dengan (last - first).

Contoh

// 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 value )
{
    vector<T> v(original_vector);

    sort( v.begin(), v.end() );
    cout << "Vector sorted by the default binary predicate <:" << 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(), value );

    cout << "Result of equal_range with value = " << value << ":" << endl << '\t';
    dump_vector( v, result );
    cout << endl;
}

template<class T, class F> void equal_range_demo( const vector<T>& original_vector, T value, 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(), value, pred );

    cout << "Result of equal_range with value = " << value << ":" << 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" );
}

Vector sorted by the default binary predicate <:
    -3 -2 -1 -1 0 0 1 2 3 4 

Result of equal_range with value = 3:
    -3 -2 -1 -1 0 0 1 2 [ 3 ] 4 

Vector sorted by the binary predicate greater:
    4 3 2 1 0 0 -1 -1 -2 -3 

Result of equal_range with value = 3:
    4 [ 3 ] 2 1 0 0 -1 -1 -2 -3 

Vector sorted by the binary predicate abs_lesser:
    0 0 -1 1 -1 2 -2 3 -3 4 

Result of equal_range with value = 3:
    0 0 -1 1 -1 2 -2 [ 3 -3 ] 4 

Vector sorted by the default binary predicate <:
    blah cute fluffy fun kittens meowmeowmeow 

Result of equal_range with value = fred:
    blah cute fluffy [ ] fun kittens meowmeowmeow 

Vector sorted by the binary predicate shorter_than:
    fun cute blah fluffy kittens meowmeowmeow 

Result of equal_range with value = fred:
    fun [ cute blah ] fluffy kittens meowmeowmeow

fill

Menetapkan nilai baru yang sama ke setiap elemen dalam rentang tertentu.

template<class ForwardIterator, class Type>
void fill(
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class Type>
void fill(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator maju yang membahas posisi elemen pertama dalam rentang yang akan dilalui.

last
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dilalui.

value
Nilai yang akan ditetapkan ke elemen dalam rentang [first, last).

Keterangan

Rentang tujuan harus valid; semua pointer harus dapat didereferensikan, dan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi. Kompleksitasnya linier dengan ukuran rentang.

Contoh

// 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

Menetapkan nilai baru ke jumlah elemen tertentu dalam rentang yang dimulai dengan elemen tertentu.

template<class OutputIterator, class Size, class Type>
OutputIterator fill_n(
    OutputIterator first,
    Size count,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Type>
ForwardIterator fill_n(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    Size count,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator output yang membahas posisi elemen pertama dalam rentang yang akan ditetapkan nilai value.

count
Jenis bilangan bulat yang ditandatangani atau tidak ditandatangani yang menentukan jumlah elemen yang akan ditetapkan nilainya.

value
Nilai yang akan ditetapkan ke elemen dalam rentang [first, first + count).

Nilai hasil

Iterator ke elemen yang mengikuti elemen terakhir yang diisi jika count> nol, jika tidak, elemen pertama.

Keterangan

Rentang tujuan harus valid; semua pointer harus dapat didereferensikan, dan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi. Kompleksitasnya linier dengan ukuran rentang.

Contoh

// 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;
}

vector v = ( 0 0 0 0 0 0 0 0 0 )
modified v = ( 1 1 1 0 0 0 0 0 0 )
modified v = ( 1 1 1 2 2 2 0 0 0 )
modified v = ( 1 1 1 2 2 2 3 3 3 )

find

Menemukan posisi kemunculan pertama elemen dalam rentang yang memiliki nilai tertentu.

template<class InputIterator, class Type>
InputIterator find(
    InputIterator first,
    InputIterator last,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class Type>
ForwardIterator find(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas posisi elemen pertama dalam rentang yang akan dicari untuk nilai yang ditentukan.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari untuk nilai yang ditentukan.

value
Nilai yang akan dicari.

Nilai hasil

Iterator input yang menangani kemunculan pertama nilai yang ditentukan dalam rentang yang sedang dicari. Jika tidak ada elemen yang ditemukan dengan nilai yang setara, mengembalikan last.

Keterangan

yang operator== digunakan untuk menentukan kecocokan antara elemen dan nilai yang ditentukan harus memaksakan hubungan kesetaraan antara operannya.

Untuk contoh kode menggunakan find(), lihat find_if.

find_end

Terlihat dalam rentang untuk subsekuensi terakhir yang identik dengan urutan tertentu atau yang setara dalam arti yang ditentukan oleh predikat biner.

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 pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
find_end(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1,
class ForwardIterator2, class BinaryPredicate>
ForwardIterator1
find_end(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

Parameter

first1
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last1
Iterator penerusan yang membahas posisi satu melewati elemen terakhir dalam rentang yang akan dicari.

first2
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last2
Iterator penerusan mengatasi posisi satu melewati elemen terakhir dalam rentang untuk dicari.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator penerusan yang membahas posisi elemen pertama dari subsekuensi terakhir dalam [first1, last1) yang cocok dengan urutan yang ditentukan [first2, last2).

Keterangan

yang operator== digunakan untuk menentukan kecocokan antara elemen dan nilai yang ditentukan harus memaksakan hubungan kesetaraan antara operannya.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan, dalam setiap urutan, posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Contoh

// 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

Mencari kemunculan pertama dari salah satu dari beberapa nilai dalam rentang target. Atau, mencari kemunculan pertama dari salah satu dari beberapa elemen yang setara dalam arti yang ditentukan oleh predikat biner ke sekumpulan elemen yang ditentukan.

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 pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
find_first_of(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1,
class ForwardIterator2, class BinaryPredicate>
ForwardIterator1
find_first_of(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

Parameter

first1
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last1
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

first2
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicocokkan.

last2
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicocokkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator penerusan yang membahas posisi elemen pertama dari subsekuensi pertama yang cocok dengan urutan yang ditentukan atau yang setara dalam arti yang ditentukan oleh predikat biner.

Keterangan

yang operator== digunakan untuk menentukan kecocokan antara elemen dan nilai yang ditentukan harus memaksakan hubungan kesetaraan antara operannya.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan, dalam setiap urutan, posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Contoh

// 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

Menemukan posisi kemunculan pertama elemen dalam rentang yang memenuhi kondisi tertentu.

template<class InputIterator, class UnaryPredicate>
InputIterator find_if(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
ForwardIterator find_if(
    ExecutionPolicy&& exec,
    ForwardIterator first, ForwardIterator last,
    UnaryPredicate pred);

Parameter

first
Iterator input yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

pred
Objek fungsi predikat yang ditentukan pengguna atau ekspresi lambda yang menentukan kondisi yang harus dipenuhi oleh elemen yang sedang dicari. Predikat unary mengambil satu argumen dan mengembalikan true jika puas, atau false jika tidak terpenuhi. Tanda tangan pred harus secara efektif adalah bool pred(const T& arg);, di mana T adalah jenis yang InputIterator dapat dikonversi secara implisit ketika didereferensikan. Kata const kunci hanya ditampilkan untuk menggambarkan bahwa objek fungsi atau lambda tidak boleh mengubah argumen.

Nilai hasil

Iterator input yang mengacu pada elemen pertama dalam rentang yang memenuhi kondisi yang ditentukan oleh predikat (predikat menghasilkan true). Jika tidak ada elemen yang ditemukan untuk memenuhi predikat, mengembalikan last.

Keterangan

Fungsi templat ini adalah generalisasi algoritma find, mengganti predikat "sama dengan nilai tertentu" dengan predikat apa pun. Untuk kebalikan logis (temukan elemen pertama yang tidak memenuhi predikat), lihat find_if_not.

Contoh

// 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");
}

array x[] contents: (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) 
Test std::find() with array...
value 10 found.
value 42 not found.
Test std::find_if() with array...
first odd integer found: 1
first even integer found: 2

vector v contents: (10) (20) (30) (40) (50) (60) (70) (80) (90) (100) 
Test std::find() with vector...
value 20 found.
value 12 not found.
Test std::find_if() with vector...
odd integer not found.
first even integer found: 10

find_if_not

Mengembalikan elemen pertama dalam rentang yang ditunjukkan yang tidak memenuhi kondisi.

template<class InputIterator, class UnaryPredicate>
InputIterator find_if_not(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
ForwardIterator find_if_not(
    ExecutionPolicy&& exec,
    ForwardIterator first, ForwardIterator last,
    UnaryPredicate pred);

Parameter

first
Iterator input yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

pred
Objek fungsi predikat yang ditentukan pengguna atau ekspresi lambda yang menentukan kondisi agar tidak puas dengan elemen yang sedang dicari. Predikat unary mengambil satu argumen dan mengembalikan true jika puas, atau false jika tidak terpenuhi. Tanda tangan pred harus secara efektif adalah bool pred(const T& arg);, di mana T adalah jenis yang InputIterator dapat dikonversi secara implisit ketika didereferensikan. Kata const kunci hanya ditampilkan untuk menggambarkan bahwa objek fungsi atau lambda tidak boleh mengubah argumen.

Nilai hasil

Iterator input yang mengacu pada elemen pertama dalam rentang yang tidak memenuhi kondisi yang ditentukan oleh predikat (predikat menghasilkan false). Jika semua elemen memenuhi predikat (predikat menghasilkan true untuk setiap elemen), mengembalikan last.

Keterangan

Fungsi templat ini adalah generalisasi algoritma find, mengganti predikat "sama dengan nilai tertentu" dengan predikat apa pun. Untuk kebalikan logis (temukan elemen pertama yang memenuhi predikat), lihat find_if.

Untuk contoh kode yang mudah disesuaikan dengan find_if_not(), lihat find_if.

for_each

Menerapkan objek fungsi tertentu ke setiap elemen dalam urutan penerusan dalam rentang dan mengembalikan objek fungsi.

template<class InputIterator, class Function>
Function for_each(
    InputIterator first,
    InputIterator last,
    Function func);

template<class ExecutionPolicy, class ForwardIterator, class Function>
void for_each(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Function func);

Parameter

first
Iterator input yang membahas posisi elemen pertama dalam rentang yang akan dioperasikan.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang yang dioperasikan.

func
Objek fungsi yang ditentukan pengguna yang diterapkan ke setiap elemen dalam rentang.

Nilai hasil

Salinan objek fungsi setelah diterapkan ke semua elemen dalam rentang.

Keterangan

Algoritma for_each ini fleksibel, memungkinkan modifikasi setiap elemen dalam rentang dengan cara yang berbeda dan ditentukan pengguna. Fungsi templat dapat digunakan kembali dalam bentuk yang dimodifikasi dengan meneruskan parameter yang berbeda. Fungsi yang ditentukan pengguna dapat mengakumulasi informasi dalam keadaan internal yang dapat dikembalikan algoritma setelah memproses semua elemen dalam rentang.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan, dalam urutan, posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier dengan perbandingan paling banyak (last - first).

Contoh

// 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& value ) : Factor ( value ) {
    }

    // 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.

for_each_n

Menerapkan objek fungsi tertentu ke sejumlah elemen tertentu dalam rentang yang dimulai dengan elemen tertentu.

template<class InputIterator, class Size, class Function>
InputIterator for_each_n(
    InputIterator first,
    Size count,
    Function func);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
ForwardIterator for_each_n(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    Size count,
    Function func);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input pada posisi elemen pertama dalam rentang yang akan dioperasikan.

count
Jumlah elemen yang akan dioperasikan.

func
Objek fungsi yang ditentukan pengguna untuk diterapkan ke setiap elemen dalam rentang [first, first + count).

Nilai hasil

Iterator ke elemen yang mengikuti elemen terakhir yang diproses jika count> nol, jika tidak, elemen pertama.

Keterangan

count harus non-negatif, dan harus ada setidaknya count elemen dalam rentang mulai dari first.

Contoh

Contoh ini mendefinisikan kelas objek fungsi. Kode produksi sering menggunakan lambda untuk mencapai hasil yang sama dengan lebih sedikit kode.

// alg_for_each_n.cpp
// compile with /EHsc and /std:c++17 (or higher)
#include <algorithm>
#include <iostream>
#include <vector>

// The function object multiplies an element by a Factor
template <class Type> class MultValue
{
private:
    Type Factor; // The value to multiply each element by
public:
    // Constructor initializes the value to multiply by
    MultValue(const Type &value) : Factor(value) {}

    // The function call for the element to be multiplied
    void operator()(Type &elem) const
    {
        elem *= Factor;
    }
};

// Utility to display the contents of a vector 
template <class T> void print_vector(const std::vector<T> &vec)
{
    std::cout << "( ";

    for (auto iter = vec.begin(); iter != vec.end(); iter++)
    {
        std::cout << *iter << ' ';
    }

    std::cout << ").\n";
}

int main()
{
    std::vector<int> v;

    // Construct vector with the elements -4...2
    for (int i = -4; i <= 2; i++)
    {
        v.push_back(i);
    }

    std::cout << "Original vector v = ";
    print_vector(v);

    // Use for_each_n to multiply the first 3 elements by a Factor,
    // saving the position in the vector after the first 3 elements
    auto pos = for_each_n(v.begin(), 3, MultValue<int>(-2));

    std::cout << "Multiplying the first 3 elements of the vector v\n "
              << "by the factor -2 gives:\n vmod1 = ";
    print_vector(v);

    // Using for_each_n to multiply the next 4 elements by a Factor,
    // starting at the position saved by the previous for_each_n
    for_each_n(pos, 4, MultValue<int>(-3));

    std::cout << "Multiplying the next 4 elements of the vector v\n "
         << "by the factor -3 gives:\n vmod2 = ";
    print_vector(v);

    return 0;
}

Original vector v = ( -4 -3 -2 -1 0 1 2 ).
Multiplying the first 3 elements of the vector v
 by the factor -2 gives:
 vmod1 = ( 8 6 4 -1 0 1 2 ).
Multiplying the next 4 elements of the vector v
 by the factor -3 gives:
 vmod2 = ( 8 6 4 3 0 -3 -6 ).

generate

Menetapkan nilai yang dihasilkan oleh objek fungsi ke setiap elemen dalam rentang.

template<class ForwardIterator, class Generator>
void generate(
    ForwardIterator first,
    ForwardIterator last,
    Generator gen);

template<class ExecutionPolicy, class ForwardIterator, class Generator>
void generate(
    ExecutionPolicy&& exec,
    ForwardIterator first, ForwardIterator last,
    Generator gen);

Parameter

first
Iterator penerusan pada posisi elemen pertama dalam rentang tempat nilai akan ditetapkan.

last
Iterator penerusan pada posisi satu melewati elemen akhir dalam rentang yang nilainya akan ditetapkan.

gen
Objek fungsi yang dipanggil tanpa argumen untuk menghasilkan nilai yang akan ditetapkan ke setiap elemen dalam rentang.

Keterangan

Objek fungsi dipanggil untuk setiap elemen dalam rentang dan tidak perlu mengembalikan nilai yang sama setiap kali dipanggil. Ini mungkin, misalnya, membaca dari file atau merujuk ke dan memodifikasi status lokal. Jenis hasil generator harus dapat dikonversi ke jenis nilai iterator penerusan untuk rentang.

Rentang yang dirujuk harus valid. Semua pointer harus dapat didereferensikan dan, dalam urutan, posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier, dengan panggilan yang tepat last - first dilakukan ke generator.

Contoh

// 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

Menetapkan nilai yang dihasilkan oleh objek fungsi ke jumlah elemen tertentu dalam rentang. Mengembalikan posisi satu melewati nilai terakhir yang ditetapkan.

template<class OutputIterator, class Diff, class Generator>
void generate_n(
    OutputIterator first,
    Diff count,
    Generator gen);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
ForwardIterator generate_n(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    Size count,
    Generator gen);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator output yang membahas posisi elemen pertama dalam rentang tempat nilai akan ditetapkan.

count
Jenis bilangan bulat yang ditandatangani atau tidak ditandatangani yang menentukan jumlah elemen yang akan ditetapkan nilai oleh fungsi generator.

gen
Objek fungsi yang dipanggil tanpa argumen yang digunakan untuk menghasilkan nilai yang akan ditetapkan ke setiap elemen dalam rentang.

Keterangan

Objek fungsi dipanggil untuk setiap elemen dalam rentang dan tidak perlu mengembalikan nilai yang sama setiap kali dipanggil. Ini mungkin, misalnya, membaca dari file atau merujuk ke dan memodifikasi status lokal. Jenis hasil generator harus dapat dikonversi ke jenis nilai iterator penerusan untuk rentang.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan, dalam urutan, posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier, dengan panggilan tepat count ke generator yang diperlukan.

Contoh

// 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);
}

vector v is: 5 8 2 -9 6 
deque dq is: 7 6 9 3 4 

includes

Menguji apakah satu rentang yang diurutkan berisi semua elemen yang terkandung dalam rentang terurut kedua, di mana kriteria pengurutan atau kesetaraan antara elemen dapat ditentukan oleh predikat biner.

template<class InputIterator1, class InputIterator2>
bool includes(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2);

template<class InputIterator1, class InputIterator2, class Compare>
bool includes(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool includes(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Compare>
bool includes(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama di rentang sumber pertama dari dua rentang sumber yang diurutkan yang akan diuji apakah semua elemen kedua terkandung dalam yang pertama.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir di rentang sumber pertama dari dua rentang sumber yang diurutkan yang akan diuji apakah semua elemen kedua terkandung dalam yang pertama.

first2
Iterator input yang membahas posisi elemen pertama dalam detik dari dua rentang sumber yang diurutkan berturut-turut yang akan diuji apakah semua elemen kedua terkandung dalam yang pertama.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk diuji apakah semua elemen kedua terkandung dalam yang pertama.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

true jika rentang pertama yang diurutkan berisi semua elemen dalam rentang kedua yang diurutkan; jika tidak, false.

Keterangan

Cara lain untuk memikirkan pengujian ini adalah menentukan apakah rentang sumber kedua adalah subset dari rentang sumber pertama.

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan, dalam setiap urutan, posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Sebagai prasyarat untuk aplikasi algoritma includes, rentang sumber yang diurutkan masing-masing harus diatur dengan urutan yang sama yang digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Rentang sumber tidak dimodifikasi oleh algoritma merge.

Jenis nilai iterator input harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara. Lebih tepatnya, algoritma menguji apakah semua elemen dalam rentang pertama yang diurutkan di bawah predikat biner tertentu memiliki urutan yang setara dengan yang ada dalam rentang kedua yang diurutkan.

Kompleksitas algoritma linier dengan paling banyak 2 * ((last1 - first1) + (last2 - first2)) - 1 perbandingan untuk rentang sumber yang tidak ada.

Contoh

// 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

Menggabungkan elemen dari dua rentang yang diurutkan berturut-turut ke dalam satu rentang yang diurutkan, di mana kriteria pengurutan dapat ditentukan oleh predikat biner.

template<class BidirectionalIterator>
void inplace_merge(
    BidirectionalIterator first,
    BidirectionalIterator middle,
    BidirectionalIterator last);

template<class BidirectionalIterator, class Compare>
void inplace_merge(
    BidirectionalIterator first,
    BidirectionalIterator middle,
    BidirectionalIterator last,
    Compare pred);

template<class ExecutionPolicy, class BidirectionalIterator>
void inplace_merge(
    ExecutionPolicy&& exec,
    BidirectionalIterator first,
    BidirectionalIterator middle,
    BidirectionalIterator last);

template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
void inplace_merge(
    ExecutionPolicy&& exec,
    BidirectionalIterator first,
    BidirectionalIterator middle,
    BidirectionalIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator dua arah yang membahas posisi elemen pertama dalam dua rentang pertama yang diurutkan berturut-turut untuk digabungkan dan diurutkan ke dalam satu rentang.

middle
Iterator dua arah yang membahas posisi elemen pertama di kedua dari dua rentang yang diurutkan berturut-turut untuk digabungkan dan diurutkan ke dalam satu rentang.

last
Iterator dua arah yang membahas posisi satu melewati elemen terakhir di kedua dari dua rentang yang diurutkan berturut-turut untuk digabungkan dan diurutkan ke dalam satu rentang.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua dan false sebaliknya.

Keterangan

Rentang berturut-turut yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan, dalam setiap urutan, posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang berturut-turut yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi inplace_merge algoritma sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan. Operasi stabil karena urutan relatif elemen dalam setiap rentang dipertahankan. Ketika ada elemen yang setara di kedua rentang sumber, elemen adalah rentang pertama yang mendahului elemen dari yang kedua dalam rentang gabungan.

Kompleksitas tergantung pada memori yang tersedia karena algoritma mengalokasikan memori ke buffer sementara. Jika memori yang cukup tersedia, kasus terbaik adalah linier dengan (last - first) - 1 perbandingan; jika tidak ada memori tambahan yang tersedia, kasus terburuk adalah N log(N), di manaN = last - first .

Contoh

// 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

Mengembalikan true jika elemen dalam rentang yang ditentukan membentuk timbunan.

template<class RandomAccessIterator>
bool is_heap(
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
bool is_heap(
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

template<class ExecutionPolicy, class RandomAccessIterator>
bool is_heap(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
bool is_heap(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator akses acak yang menunjukkan awal rentang untuk memeriksa timbunan.

last
Iterator akses acak yang menunjukkan akhir rentang.

pred
Kondisi untuk menguji untuk mengurutkan elemen. Predikat perbandingan mengambil dua argumen dan mengembalikan true atau false.

Nilai hasil

Mengembalikan true jika elemen dalam rentang yang ditentukan membentuk timbunan, false jika tidak.

Keterangan

Fungsi templat pertama mengembalikan is_heap_until(first , last) == last.

Fungsi templat kedua mengembalikan

is_heap_until(first, last, pred) == last.

is_heap_until

Mengembalikan iterator yang diposisikan pada elemen pertama dalam rentang [ first, ) lastyang tidak memenuhi kondisi pengurutan timbunan, atau end jika rentang membentuk timbunan.

template<class RandomAccessIterator>
RandomAccessIterator is_heap_until(
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
RandomAccessIterator is_heap_until(
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

template<class ExecutionPolicy, class RandomAccessIterator>
RandomAccessIterator is_heap_until(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
RandomAccessIterator is_heap_until(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator akses acak yang menentukan elemen pertama rentang untuk memeriksa timbunan.

last
Iterator akses acak yang menentukan akhir rentang untuk memeriksa timbunan.

pred
Predikat biner yang menentukan kondisi pengurutan lemah yang ketat yang mendefinisikan timbunan. Predikat default adalah std::less<> kapan pred tidak ditentukan.

Nilai hasil

Mengembalikan last jika rentang yang ditentukan membentuk timbunan atau berisi satu atau lebih sedikit elemen. Jika tidak, mengembalikan iterator untuk elemen pertama yang ditemukan yang tidak memenuhi kondisi tumpukan.

Keterangan

Fungsi templat pertama mengembalikan iterator next terakhir di mana [first, last) adalah timbunan yang diurutkan [first, next) oleh objek std::less<>fungsi . Jika jaraknya last - first kurang dari 2, fungsi akan mengembalikan last.

Fungsi templat kedua bereaksi sama dengan yang pertama, kecuali menggunakan predikat pred alih-alih std::less<> sebagai kondisi pengurutan timbunan.

is_partitioned

Mengembalikan true jika semua elemen dalam rentang tertentu yang menguji true kondisi datang sebelum elemen apa pun yang menguji false.

template<class InputIterator, class UnaryPredicate>
bool is_partitioned(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template <class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
bool is_partitioned(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan di mana rentang mulai memeriksa kondisi.

last
Iterator input yang menunjukkan akhir rentang.

pred
Kondisi untuk diuji. Pengujian ini disediakan oleh objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang harus dipenuhi oleh elemen yang sedang dicari. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

true Mengembalikan ketika semua elemen dalam rentang tertentu yang menguji true kondisi datang sebelum elemen apa pun yang menguji false, dan jika tidak, mengembalikan false.

Keterangan

Fungsi templat hanya mengembalikan true jika semua elemen dipartisi [first, last) oleh pred; yaitu, semua elemen X[first, last) yang pred (X) benar terjadi sebelum semua elemen Y yang pred (Y) mana adalah false.

is_permutation

Mengembalikan true jika kedua rentang berisi elemen yang sama, apakah elemen berada dalam urutan yang sama atau tidak. Gunakan kelebihan beban rentang ganda dalam kode C++14 karena kelebihan beban yang hanya mengambil satu iterator untuk rentang kedua tidak akan mendeteksi perbedaan jika rentang kedua lebih panjang dari rentang pertama. Kelebihan beban ini akan mengakibatkan perilaku yang tidak ditentukan jika rentang kedua lebih pendek dari rentang pertama.

template<class ForwardIterator1, class ForwardIterator2>
bool is_permutation(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2);

template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
bool is_permutation(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    BinaryPredicate 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 BinaryPredicate>
bool is_permutation(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

Parameter

first1
Iterator penerusan yang mengacu pada elemen pertama rentang.

last1
Iterator penerusan yang merujuk satu melewati elemen terakhir rentang.

first2
Iterator penerusan yang mengacu pada elemen pertama dari rentang kedua, digunakan untuk perbandingan.

last2
Iterator penerusan yang mengacu pada satu melewati elemen terakhir dari rentang kedua, yang digunakan untuk perbandingan.

pred
Predikat yang menguji kesetaraan dan mengembalikan bool.

Nilai hasil

true ketika rentang dapat diatur ulang sehingga identik sesuai dengan predikat komparator; jika tidak, false.

Keterangan

is_permutation memiliki kompleksitas kuadrat dalam kasus terburuk.

Fungsi templat pertama mengasumsikan bahwa ada sebanyak mungkin elemen dalam rentang yang dimulai pada first2 karena ada dalam rentang yang ditunjuk oleh [first1, last1). Jika ada lebih banyak elemen dalam rentang kedua, elemen tersebut diabaikan; jika ada kurang, perilaku yang tidak ditentukan akan terjadi. Fungsi templat ketiga (C++14 dan yang lebih baru) tidak membuat asumsi ini. Keduanya hanya mengembalikan true jika, untuk setiap elemen X dalam rentang yang ditunjuk oleh [first1, last1) ada banyak elemen Y dalam rentang yang sama yang X == Y ada dalam rentang yang dimulai pada first2 atau [first2, last2). Di sini, operator== harus melakukan perbandingan berpasangan antara operannya.

Fungsi templat kedua dan keempat berulah sama, kecuali bahwa mereka mengganti operator==(X, Y) dengan Pred(X, Y). Agar berperilaku benar, predikatnya harus simetris, refleksif, dan transitif.

Contoh

Contoh berikut menunjukkan cara menggunakan 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

    return 0;
}

(1) Compare using built-in == operator: true
(2) Compare after modifying vec_2: false
(3) vec_3 is a permutation of vec_4: true
animals_2 is a permutation of animals_1: true

is_sorted

Mengembalikan true jika elemen dalam rentang yang ditentukan dalam urutan yang diurutkan.

template<class ForwardIterator>
bool is_sorted(
    ForwardIterator first,
    ForwardIterator last);

template<class ForwardIterator, class Compare>
bool is_sorted(
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

template<class ExecutionPolicy, class ForwardIterator>
bool is_sorted(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>
bool is_sorted(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menunjukkan di mana rentang yang akan diperiksa dimulai.

last
Iterator penerusan yang menunjukkan akhir rentang.

pred
Kondisi yang akan diuji untuk menentukan urutan antara dua elemen. Predikat perbandingan mengambil dua argumen dan mengembalikan true atau false. Predikat ini melakukan tugas yang sama dengan operator<.

Keterangan

Fungsi templat pertama mengembalikan is_sorted_until( first, last ) == last. Fungsi ini operator< melakukan perbandingan pesanan.

Fungsi templat kedua mengembalikan is_sorted_until( first, last , pred ) == last. Fungsi pred predikat melakukan perbandingan pesanan.

is_sorted_until

Mengembalikan ForwardIterator yang diatur ke elemen terakhir yang dalam urutan diurutkan dari rentang tertentu.

Versi kedua memungkinkan Anda memberikan objek fungsi perbandingan yang kembali true ketika dua elemen tertentu dalam urutan yang diurutkan, dan false sebaliknya.

template<class ForwardIterator>
ForwardIterator is_sorted_until(
    ForwardIterator first,
    ForwardIterator last);

template<class ForwardIterator, class Compare>
ForwardIterator is_sorted_until(
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator is_sorted_until(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>
ForwardIterator is_sorted_until(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menunjukkan di mana rentang yang akan diperiksa dimulai.

last
Iterator penerusan yang menunjukkan akhir rentang.

pred
Kondisi yang akan diuji untuk menentukan urutan antara dua elemen. Predikat perbandingan mengambil dua argumen dan mengembalikan true atau false.

Nilai hasil

Mengembalikan set ForwardIterator ke elemen terakhir dalam urutan yang diurutkan. Urutan yang diurutkan dimulai dari first.

Keterangan

Fungsi templat pertama mengembalikan iterator next terakhir sehingga [first, last] merupakan urutan yang diurutkan yang diurutkan [first, next) menurut operator<. Jika distance() kurang dari 2, fungsi mengembalikan last.

Fungsi templat kedua berulah sama, kecuali diganti operator<(X, Y) dengan pred(X, Y).

iter_swap

Menukar dua nilai yang dimaksud oleh sepasang iterator tertentu.

template<class ForwardIterator1, class ForwardIterator2>
void iter_swap( ForwardIterator1 left, ForwardIterator2 right );

Parameter

left
Salah satu iterator penerusan yang nilainya akan ditukar.

right
Yang kedua dari iterator penerusan yang nilainya akan ditukar.

Keterangan

swap harus digunakan dalam preferensi untuk iter_swap, yang disertakan dalam Standar C++ untuk kompatibilitas mundur. Jika Fit1 dan Fit2 meneruskan iterator, maka iter_swap( Fit1, Fit2 ), setara dengan swap( *Fit1, *Fit2 ).

Jenis nilai iterator penerusan input harus memiliki nilai yang sama.

Contoh

// 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

Membandingkan elemen berdasarkan elemen antara dua urutan untuk menentukan mana yang lebih kecil dari keduanya.

template<class InputIterator1, class InputIterator2>
bool lexicographical_compare(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2 );

template<class InputIterator1, class InputIterator2, class Compare>
bool lexicographical_compare(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool lexicographical_compare(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Compare>
bool lexicographical_compare(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama dalam rentang pertama yang akan dibandingkan.

last1
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang pertama yang akan dibandingkan.

first2
Iterator input yang membahas posisi elemen pertama dalam rentang kedua yang akan dibandingkan.

last2
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang kedua yang akan dibandingkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

true jika rentang pertama secara leksikografis kurang dari rentang kedua; jika tidak false.

Keterangan

Perbandingan leksikografis antara urutan membandingkannya dengan elemen hingga:

• Ini menemukan dua elemen yang sesuai tidak sama, dan hasil perbandingannya diambil sebagai hasil dari perbandingan antara urutan.

• Tidak ada ketidaksetaraan yang ditemukan, tetapi satu urutan memiliki lebih banyak elemen daripada yang lain, dan urutan yang lebih pendek dianggap kurang dari urutan yang lebih lama.

• Tidak ada ketidaksetaraan yang ditemukan dan urutannya memiliki jumlah elemen yang sama, sehingga urutannya sama dan hasil perbandingannya adalah false.

Contoh

// 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

Menemukan posisi elemen pertama dalam rentang berurutan yang memiliki nilai lebih besar dari atau setara dengan nilai yang ditentukan. Kriteria pemesanan dapat ditentukan oleh predikat biner.

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 pred );

Parameter

first
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

value
Nilai yang posisi pertamanya atau kemungkinan posisi pertamanya sedang dicari dalam rentang yang diurutkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator penerusan pada posisi elemen pertama dalam rentang yang diurutkan dengan nilai yang lebih besar dari atau setara dengan nilai yang ditentukan. Kesetaraan dapat ditentukan dengan predikat biner.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua iterator harus dapat didereferensikan dan dalam urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang yang diurutkan adalah prasyarat penggunaan lower_bound dan di mana pengurutan sama dengan yang ditentukan dengan predikat biner.

Rentang tidak dimodifikasi oleh algoritma lower_bound.

Jenis nilai iterator penerusan harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara.

Kompleksitas algoritma adalah logaritma untuk iterator akses acak dan linear jika tidak, dengan jumlah langkah yang proporsional dengan (last - first).

Contoh

// 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;
}

Starting vector v1 = ( -1 0 1 2 3 4 -3 -2 -1 0 ).
Original vector v1 with range sorted by the
 binary predicate less than is v1 = ( -3 -2 -1 -1 0 0 1 2 3 4 ).
Original vector v2 with range sorted by the
 binary predicate greater is v2 = ( 4 3 2 1 0 0 -1 -1 -2 -3 ).
Original vector v3 with range sorted by the
 binary predicate mod_lesser is v3 = ( 0 0 -1 -1 1 -2 2 -3 3 4 ).
The lower_bound in v1 for the element with a value of 3 is: 3.
The lower_bound in v2 for the element with a value of 3 is: 3.
The lower_bound in v3 for the element with a value of 3 is: -3.

make_heap

Mengonversi elemen dari rentang tertentu menjadi timbunan di mana elemen pertama adalah yang terbesar dan yang kriteria pengurutannya dapat ditentukan dengan predikat biner.

template<class RandomAccessIterator>
void make_heap(
    RandomAccessIterator first,
    RandomAccessIterator last );

template<class RandomAccessIterator, class BinaryPredicate>
void make_heap(
    RandomAccessIterator first,
    RandomAccessIterator last,
    BinaryPredicate pred );

Parameter

first
Iterator akses acak yang membahas posisi elemen pertama dalam rentang yang akan dikonversi menjadi tumpukan.

last
Iterator akses acak yang membahas posisi satu melewati elemen akhir dalam rentang untuk dikonversi menjadi tumpukan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

Timbunan memiliki dua properti:

• Elemen pertama selalu yang terbesar.

• Elemen dapat ditambahkan atau dihapus dalam waktu logaritmik.

Tumpukan adalah cara ideal untuk menerapkan antrean prioritas dan digunakan dalam implementasi adaptor kontainer C++ Standard Library priority_queue Class.

Kompleksitasnya linier, membutuhkan 3 * (last - first) perbandingan.

Contoh

// 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;
}

Vector v1 is ( 4 3 7 8 0 5 2 1 6 9 ).
The heaped version of vector v1 is ( 9 8 7 6 3 5 2 1 4 0 ).
The greater-than heaped version of v1 is ( 0 1 2 4 3 5 7 6 9 8 ).

max

Membandingkan dua objek dan mengembalikan yang lebih besar dari keduanya, di mana kriteria pemesanan dapat ditentukan oleh predikat biner.

template<class Type>
constexpr Type& max(
    const Type& left,
    const Type& right);
template<class Type, class Pr>
constexpr Type& max(
    const Type& left,
    const Type& right,
    BinaryPredicate pred);
template<class Type>
constexpr Type& max (
    initializer_list<Type> ilist);
template<class Type, class Pr>
constexpr Type& max(
    initializer_list<Type> ilist,
    BinaryPredicate pred);

Parameter

left
Yang pertama dari dua objek yang dibandingkan.

right
Yang kedua dari dua objek yang dibandingkan.

pred
Predikat biner yang digunakan untuk membandingkan dua objek.

inlist
Daftar penginisialisasi yang berisi objek yang akan dibandingkan.

Nilai hasil

Yang lebih besar dari dua objek itu, kecuali jika tidak ada yang lebih besar dari itu. dalam hal ini, mengembalikan yang pertama dari dua objek. initializer_list Ketika ditentukan, objek akan menampilkan objek terbesar dalam daftar.

Keterangan

max Algoritma tidak biasa dalam memiliki objek yang diteruskan sebagai parameter. Sebagian besar algoritma Pustaka Standar C++ beroperasi pada berbagai elemen yang posisinya ditentukan oleh iterator yang diteruskan sebagai parameter. Jika Anda memerlukan fungsi yang beroperasi pada berbagai elemen, gunakan max_element sebagai gantinya. Visual Studio 2017 memungkinkan constexpr kelebihan beban yang mengambil initializer_list.

Contoh

// 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: 6
The integer with 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

Menemukan kemunculan pertama elemen terbesar dalam rentang tertentu di mana kriteria pemesanan dapat ditentukan oleh predikat biner.

template<class ForwardIterator>
constexpr ForwardIterator max_element(
    ForwardIterator first,
    ForwardIterator last );

template<class ForwardIterator, class Compare>
constexpr ForwardIterator max_element(
    ForwardIterator first,
    ForwardIterator last,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator max_element(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>
ForwardIterator max_element(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator maju yang membahas posisi elemen pertama dalam rentang yang akan dicari untuk elemen terbesar.

last
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari untuk elemen terbesar.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua dan false sebaliknya.

Nilai hasil

Iterator maju yang membahas posisi kemunculan pertama elemen terbesar dalam rentang yang dicari.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier: (last - first) - 1 perbandingan diperlukan untuk rentang yang tidak ada.

Contoh

// 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;
}

s1 = ( CInt( -3 ), CInt( 1 ), CInt( 2 ) ).
The largest element in s1 is: CInt( 2 )

Vector v1 is ( 0 1 2 3 -2 -4 -6 -8 ).
The largest element in v1 is: 3
The largest element in v1 under the mod_lesser
 binary predicate is: -8

merge

Menggabungkan semua elemen dari dua rentang sumber yang diurutkan ke dalam satu rentang tujuan yang diurutkan, di mana kriteria pemesanan dapat ditentukan oleh predikat biner.

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result );

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator merge(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator>
ForwardIterator merge(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare>
ForwardIterator merge(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk digabungkan dan diurutkan ke dalam satu rentang.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk digabungkan dan diurutkan ke dalam satu rentang.

first2
Iterator input yang membahas posisi elemen pertama dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk digabungkan dan diurutkan ke dalam satu rentang.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk digabungkan dan diurutkan ke dalam satu rentang.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan di mana dua rentang sumber akan digabungkan ke dalam satu rentang yang diurutkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua, dan false sebaliknya.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen terakhir dalam rentang tujuan yang diurutkan.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang tujuan tidak boleh tumpang tindih dengan salah satu rentang sumber dan harus cukup besar untuk berisi rentang tujuan.

Rentang sumber yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi merge algoritma sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Operasi stabil karena urutan relatif elemen dalam setiap rentang dipertahankan dalam rentang tujuan. Rentang sumber tidak dimodifikasi oleh algoritma merge.

Jenis nilai iterator input harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara. Ketika ada elemen yang setara di kedua rentang sumber, elemen dalam rentang pertama mendahului elemen dari rentang sumber kedua dalam rentang tujuan.

Kompleksitas algoritma linier dengan paling banyak (last1 - first1) - (last2 - first2) - 1 perbandingan.

list menyediakan fungsi merge anggota untuk menggabungkan elemen dari dua daftar.

Contoh

// 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;
}

Original vector v1a with range sorted by the
 binary predicate less than is v1a = ( 0 1 2 3 4 5 ).
Original vector v1b with range sorted by the
 binary predicate less than is v1b = ( -5 -4 -3 -2 -1 0 ).
Original vector v2a with range sorted by the
 binary predicate greater is   v2a = ( 5 4 3 2 1 0 ).
Original vector v2b with range sorted by the
 binary predicate greater is   v2b = ( 0 -1 -2 -3 -4 -5 ).
Original vector v3a with range sorted by the
 binary predicate mod_lesser is   v3a = ( 0 1 2 3 4 5 ).
Original vector v3b with range sorted by the
 binary predicate mod_lesser is   v3b = ( 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 ).

min

Membandingkan dua objek dan mengembalikan yang lebih kecil dari keduanya, di mana kriteria pemesanan dapat ditentukan oleh predikat biner.

template<class Type>
constexpr const Type& min(
    const Type& left,
    const Type& right);

template<class Type, class Pr>
constexpr const Type& min(
    const Type& left,
    const Type& right,
    BinaryPredicate pred);

template<class Type>
constexpr Type min(
    initializer_list<Type> ilist);

template<class Type, class Pr>
constexpr Type min(
    initializer_list<Type> ilist,
    BinaryPredicate pred);

Parameter

left
Yang pertama dari dua objek yang dibandingkan.

right
Yang kedua dari dua objek yang dibandingkan.

pred
Predikat biner yang digunakan untuk membandingkan dua objek.

inlist
initializer_list yang berisi anggota yang akan dibandingkan.

Nilai hasil

Lebih rendah dari dua objek, kecuali tidak kurang; dalam hal ini, mengembalikan yang pertama dari dua objek. initializer_list Ketika ditentukan, objek mengembalikan objek paling sedikit dalam daftar.

Keterangan

min Algoritma tidak biasa dalam memiliki objek yang diteruskan sebagai parameter. Sebagian besar algoritma Pustaka Standar C++ beroperasi pada berbagai elemen yang posisinya ditentukan oleh iterator yang diteruskan sebagai parameter. Jika Anda memerlukan fungsi yang menggunakan berbagai elemen, gunakan min_element. constexpr diaktifkan pada initializer_list kelebihan beban di Visual Studio 2017.

Contoh

// 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

Menemukan kemunculan pertama elemen terkecil dalam rentang tertentu di mana kriteria pengurutan dapat ditentukan oleh predikat biner.

template<class ForwardIterator>
constexpr ForwardIterator min_element(
    ForwardIterator first,
    ForwardIterator last );

template<class ForwardIterator, class Compare>
constexpr ForwardIterator min_element(
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator min_element(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>
ForwardIterator min_element(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator maju yang membahas posisi elemen pertama dalam rentang yang akan dicari untuk elemen terkecil.

last
Iterator penerusan mengatasi posisi satu melewati elemen akhir dalam rentang yang akan dicari untuk elemen terkecil.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua, dan false sebaliknya.

Nilai hasil

Iterator maju yang membahas posisi kemunculan pertama elemen terkecil dalam rentang yang dicari.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier: (last - first) - 1 perbandingan diperlukan untuk rentang yang tidak ada.

Contoh

// 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

Melakukan pekerjaan yang dilakukan oleh min_element dan max_element dalam satu panggilan.

template<class ForwardIterator>
constexpr pair<ForwardIterator, ForwardIterator> minmax_element(
    ForwardIterator first,
    ForwardIterator last);

template<class ForwardIterator, class Compare>
constexpr pair<ForwardIterator, ForwardIterator> minmax_element(
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

template<class ExecutionPolicy, class ForwardIterator>
pair<ForwardIterator, ForwardIterator> minmax_element(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>
pair<ForwardIterator, ForwardIterator> minmax_element(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menunjukkan awal rentang.

last
Iterator penerusan yang menunjukkan akhir rentang.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan harus kembali true ketika yang pertama kurang dari yang kedua, dan false sebaliknya.

Nilai hasil

Mengembalikan

pair<ForwardIterator, ForwardIterator>( min_element(first, last), max_element(first, last)).

Keterangan

Fungsi templat pertama mengembalikan

pair<ForwardIterator,ForwardIterator>(min_element(first,last), max_element(first,last)).

Fungsi templat kedua berulah sama, kecuali diganti operator<(X, Y) dengan pred(X, Y).

Jika urutannya tidak kosong, fungsi melakukan paling banyak 3 * (last - first - 1) / 2 perbandingan.

minmax

Membandingkan dua parameter input dan mengembalikannya sebagai pasangan, agar lebih kecil dengan yang lebih besar.

template<class Type>
constexpr pair<const Type&, const Type&> minmax(
    const Type& left,
    const Type& right);

template<class Type, class BinaryPredicate>
constexpr pair<const Type&, const Type&> minmax(
    const Type& left,
    const Type& right,
    BinaryPredicate pred);

template<class Type>
constexpr pair<Type&, Type&> minmax(
    initializer_list<Type> ilist);

template<class Type, class BinaryPredicate>
constexpr pair<Type&, Type&> minmax(
    initializer_list<Type> ilist,
    BinaryPredicate pred);

Parameter

left
Yang pertama dari dua objek yang dibandingkan.

right
Yang kedua dari dua objek yang dibandingkan.

pred
Predikat biner yang digunakan untuk membandingkan dua objek.

inlist
initializer_list yang berisi anggota yang akan dibandingkan.

Keterangan

Fungsi templat pertama mengembalikan pair<const Type&, const Type&>( right, left ) jika right kurang dari left. Jika tidak, ia kembali pair<const Type&, const Type&>( left, right ).

Fungsi anggota kedua mengembalikan pasangan di mana elemen pertama lebih kecil dan yang kedua lebih besar jika dibandingkan dengan predikat pred.

Fungsi templat yang tersisa berulah sama, kecuali bahwa mereka mengganti left parameter dan right dengan inlist.

Fungsi ini melakukan tepat satu perbandingan.

mismatch

Membandingkan dua elemen rentang berdasarkan elemen dan menemukan posisi pertama di mana perbedaan terjadi.

Gunakan kelebihan beban rentang ganda dalam kode C++14 karena kelebihan beban yang hanya mengambil satu iterator untuk rentang kedua tidak akan mendeteksi perbedaan jika rentang kedua lebih panjang dari rentang pertama. Kelebihan beban ini akan mengakibatkan perilaku yang tidak ditentukan jika rentang kedua lebih pendek dari rentang pertama.

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 pred );

//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 pred);

//C++17
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
pair<ForwardIterator1, ForwardIterator2>
mismatch(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
pair<ForwardIterator1, ForwardIterator2>
mismatch(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
pair<ForwardIterator1, ForwardIterator2>
mismatch(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
pair<ForwardIterator1, ForwardIterator2>
mismatch(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama dalam rentang pertama yang akan diuji.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir dalam rentang pertama yang akan diuji.

first2
Iterator input yang membahas posisi elemen pertama dalam rentang kedua yang akan diuji.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam rentang kedua yang akan diuji.

pred
Objek fungsi predikat yang ditentukan pengguna yang membandingkan elemen saat ini di setiap rentang dan menentukan apakah elemen tersebut setara. Ini kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Mengembalikan sepasang iterator yang mengatasi posisi ketidakcocokan dalam dua rentang. Iterator komponen pertama menunjuk ke posisi di rentang pertama. Iterator komponen kedua menunjuk ke posisi dalam rentang kedua. Jika tidak ada perbedaan antara elemen dalam rentang dibandingkan atau jika predikat biner dalam versi kedua dipenuhi oleh semua pasangan elemen dari dua rentang, maka iterator komponen pertama menunjuk ke posisi satu melewati elemen akhir di rentang pertama dan iterator komponen kedua menunjuk ke posisi satu melewati elemen kedua.

Keterangan

Fungsi templat pertama mengasumsikan bahwa ada sebanyak mungkin elemen dalam rentang yang dimulai pada awalnya2 karena ada dalam rentang yang ditunjuk oleh [first1, last1). Jika ada lebih banyak di rentang kedua, mereka diabaikan; jika ada kurang, perilaku yang tidak ditentukan akan dihasilkan.

Rentang yang akan dicari harus valid; semua iterator harus dapat didereferensikan dan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitas waktu algoritma linier dalam jumlah elemen yang terkandung dalam rentang yang lebih pendek.

Predikat yang ditentukan pengguna tidak diperlukan untuk memaksakan hubungan kesetaraan yang simetris, refleksif, dan transitif di antara operannya.

Contoh

Contoh berikut menunjukkan cara menggunakan ketidakcocokan. Kelebihan beban C++03 hanya ditampilkan untuk menunjukkan bagaimana hal itu dapat menghasilkan hasil yang tidak terduga.

#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 isn't a symmetric, reflexive, and transitive equivalence.
// mismatch and equal accept such predicates, but is_permutation doesn't.
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;

}

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> move

Pindahkan elemen yang terkait dengan rentang tertentu.

template<class InputIterator, class OutputIterator>
OutputIterator move(
    InputIterator first,
    InputIterator last,
    OutputIterator dest);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 move(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan tempat memulai rentang elemen untuk dipindahkan.

last
Iterator input yang menunjukkan akhir rentang elemen untuk dipindahkan.

dest
Iterator output yang berisi elemen yang dipindahkan.

Keterangan

Fungsi templat mengevaluasi *(dest + N) = move(*(first + N)) sekali untuk masing-masing N dalam rentang [0, last - first), untuk meningkatkan nilai N yang benar-benar dimulai dengan nilai terendah. Kemudian mengembalikan dest + N. Jika dest dan first menunjuk wilayah penyimpanan, dest tidak boleh berada dalam rentang [first, last).

move_backward

Memindahkan elemen satu iterator ke iterator lainnya. Pemindahan dimulai dengan elemen terakhir dalam rentang tertentu, dan berakhir dengan elemen pertama dalam rentang tersebut.

template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 move_backward(
    BidirectionalIterator1 first,
    BidirectionalIterator1 last,
    BidirectionalIterator2 destEnd);

Parameter

first
Iterator yang menunjukkan awal rentang untuk memindahkan elemen.

last
Iterator yang menunjukkan akhir rentang untuk memindahkan elemen. Elemen ini tidak dipindahkan.

destEnd
Iterator dua arah yang membahas posisi satu melewati elemen akhir dalam rentang tujuan.

Keterangan

Fungsi templat mengevaluasi *(destEnd - N - 1) = move(*(last - N - 1)) sekali untuk masing-masing N dalam rentang [0, last - first), untuk meningkatkan nilai N yang benar-benar dimulai dengan nilai terendah. Kemudian mengembalikan destEnd - (last - first). Jika destEnd dan first menunjuk wilayah penyimpanan, destEnd tidak boleh berada dalam rentang [first, last).

move dan move_backward secara fungsional setara dengan menggunakan copy dan copy_backward dengan iterator pemindahan.

next_permutation

Menyusun ulang elemen dalam rentang sehingga urutan asli digantikan oleh permutasi yang lebih besar secara leksikografis berikutnya jika ada. Pengertian leksikografis berikutnya dapat ditentukan dengan predikat biner.

template<class BidirectionalIterator>
bool next_permutation(
    BidirectionalIterator first,
    BidirectionalIterator last);

template<class BidirectionalIterator, class BinaryPredicate>
bool next_permutation(
    BidirectionalIterator first,
    BidirectionalIterator last,
    BinaryPredicate pred);

Parameter

first
Iterator dua arah yang menunjuk ke posisi elemen pertama dalam rentang yang akan dialihkan.

last
Iterator dua arah yang menunjuk ke posisi satu melewati elemen akhir dalam rentang yang akan dialihkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

true jika permutasi berikutnya secara leksikografis ada dan telah menggantikan urutan asli rentang; jika tidak false, dalam hal ini pengurutan diubah menjadi permutasi terkecil secara leksikografis.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Predikat biner default kurang dari dan elemen dalam rentang harus kurang dari sebanding untuk memastikan bahwa permutasi berikutnya didefinisikan dengan baik.

Kompleksitasnya linier dengan paling banyak (last - first) / 2 pertukaran.

Contoh

// 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

Mempartisi berbagai elemen, menemukan elemen nth dengan benar dari urutan dalam rentang yang memenuhi kriteria ini: Semua elemen di depannya kurang dari atau sama dengannya, dan semua elemen yang mengikutinya lebih besar dari atau sama dengannya.

template<class RandomAccessIterator>
void nth_element(
    RandomAccessIterator first,
    RandomAccessIterator nth,
    RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
void nth_element(
    RandomAccessIterator first,
    RandomAccessIterator nth,
    RandomAccessIterator last,
    Compare pred);

template<class ExecutionPolicy, class RandomAccessIterator>
void nth_element(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator nth,
    RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void nth_element(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator nth,
    RandomAccessIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator akses acak yang membahas posisi elemen pertama dalam rentang yang akan dipartisi.

nth
Iterator akses acak yang mengatasi posisi elemen yang akan diurutkan dengan benar pada batas partisi.

last
Iterator akses acak yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dipartisi.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat perbandingan mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

nth_element Algoritma tidak menjamin bahwa elemen dalam subranges salah satu sisi elemen nth diurutkan. Dengan demikian membuat lebih sedikit jaminan daripada partial_sort, yang mengurutkan elemen dalam rentang di bawah beberapa elemen yang dipilih, dan dapat digunakan sebagai alternatif yang lebih cepat ketika partial_sort pengurutan rentang bawah tidak diperlukan.

Elemen setara, tetapi belum tentu sama, jika tidak kurang dari yang lain.

Rata-rata kompleksitas sortiran linier sehubungan last - firstdengan .

Contoh

// 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;
}

 v1 = ( 0 3 6 9 12 15 1 4 7 10 13 16 2 5 8 11 14 17 )
Position 3 partitioned vector:
 v1 = ( 1 0 2 3 8 5 9 4 7 6 10 16 13 15 12 11 14 17 )
Position 4 partitioned (greater) vector:
 v1 = ( 16 17 14 15 13 12 11 9 7 8 10 6 1 4 5 3 2 0 )
Shuffled vector:
 v1 = ( 13 10 6 3 5 2 0 17 11 8 15 9 7 14 16 1 12 4 )
Position 5 partitioned (UDgreater) vector:
 v1 = ( 14 17 15 16 13 12 10 11 9 8 0 2 7 5 3 1 6 4 )

none_of

true Mengembalikan ketika kondisi tidak pernah ada di antara elemen dalam rentang yang diberikan.

template<class InputIterator, class UnaryPredicate>
bool none_of(
    InputIterator first,
    InputIterator last,
    UnaryPredicate pred);

template <class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
bool none_of(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan tempat untuk mulai memeriksa berbagai elemen untuk suatu kondisi.

last
Iterator input yang menunjukkan akhir dari berbagai elemen.

pred
Kondisi untuk diuji. Pengujian ini disediakan oleh objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

Mengembalikan true jika kondisi tidak terdeteksi setidaknya sekali dalam rentang yang ditunjukkan, dan false jika kondisi terdeteksi.

Keterangan

Fungsi templat hanya mengembalikan true jika, untuk beberapa N dalam rentang [0, last - first), predikatnya pred(*(first + N)) selalu false.

partial_sort

Mengatur jumlah elemen yang lebih kecil yang ditentukan dalam rentang ke dalam urutan yang tidak menurun. Predikat biner dapat memberikan kriteria pemesanan.

template<class RandomAccessIterator>
void partial_sort(
    RandomAccessIterator first,
    RandomAccessIterator sortEnd,
    RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
void partial_sort(
    RandomAccessIterator first,
    RandomAccessIterator sortEnd,
    RandomAccessIterator last,
    Compare pred);

template<class ExecutionPolicy, class RandomAccessIterator>
void partial_sort(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator middle,
    RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void partial_sort(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator middle,
    RandomAccessIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator akses acak yang mengatasi posisi elemen pertama dalam rentang yang akan diurutkan.

sortEnd
Iterator akses acak yang mengatasi posisi satu melewati elemen akhir di subjumlah yang akan diurutkan.

last
Iterator akses acak yang membahas posisi satu melewati elemen akhir dalam rentang yang akan diurutkan sebagian.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Elemen setara, tetapi belum tentu sama, jika tidak kurang dari yang lain. sort Algoritma tidak stabil dan tidak menjamin bahwa pengurutan relatif elemen yang setara akan dipertahankan. Algoritma stable_sort mempertahankan urutan asli ini.

Kompleksitas pengurutan parsial rata-rata adalah log O((last- ) (firstsortEnd- )).first

Contoh

// 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

Menyalin elemen dari rentang sumber ke dalam rentang tujuan di mana elemen sumber diurutkan berdasarkan predikat biner yang kurang dari atau yang ditentukan lainnya.

template<class InputIterator, class RandomAccessIterator>
RandomAccessIterator partial_sort_copy(
    InputIterator first1,
    InputIterator last1,
    RandomAccessIterator first2,
    RandomAccessIterator last2 );

template<class InputIterator, class RandomAccessIterator, class Compare>
RandomAccessIterator partial_sort_copy(
    InputIterator first1,
    InputIterator last1,
    RandomAccessIterator first2,
    RandomAccessIterator last2,
    Compare pred);

template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>
RandomAccessIterator partial_sort_copy(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    RandomAccessIterator result_first,
    RandomAccessIterator result_last);

template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator, class Compare>
RandomAccessIterator partial_sort_copy(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    RandomAccessIterator result_first,
    RandomAccessIterator result_last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama dalam rentang sumber.

last1
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang sumber.

first2
Iterator akses acak yang mengatasi posisi elemen pertama dalam rentang tujuan yang diurutkan.

last2
Iterator akses acak yang mengatasi posisi satu melewati elemen akhir dalam rentang tujuan yang diurutkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator akses acak yang menangani elemen dalam rentang tujuan satu posisi di luar elemen terakhir yang disisipkan dari rentang sumber.

Keterangan

Rentang sumber dan tujuan tidak boleh tumpang tindih dan harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Predikat biner harus memberikan urutan lemah yang ketat sehingga elemen yang tidak setara diurutkan, tetapi elemen yang setara tidak. Dua elemen setara di bawah kurang dari, tetapi tidak selalu sama, jika tidak kurang dari yang lain.

Contoh

// 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;
}

Vector v1 = ( 4 3 7 8 0 5 2 1 6 9 )
List list1 = ( 60 50 20 30 40 10 )
List list1 Vector v1 = ( 10 20 30 8 0 5 2 1 6 9 )
The first v1 element one position beyond
 the last L 1 element inserted was 8.
List list1 into Vector v2 = ( 10 20 30 40 50 60 9 6 7 8 )
The first v2 element one position beyond
 the last L 1 element inserted was 9.

partition

Mengklasifikasikan elemen dalam rentang menjadi dua set yang terputus-putus, dengan elemen-elemen tersebut memenuhi predikat unary yang mendahului yang gagal memuaskannya.

template<class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator partition(
    BidirectionalIterator first,
    BidirectionalIterator last,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
ForwardIterator partition(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator dua arah yang membahas posisi elemen pertama dalam rentang yang akan dipartisi.

last
Iterator dua arah yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dipartisi.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang harus dipenuhi jika elemen akan diklasifikasikan. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

Iterator dua arah yang membahas posisi elemen pertama dalam rentang untuk tidak memenuhi kondisi predikat.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

a Elemen dan b setara, tetapi belum tentu sama, jika keduanya pred( a, b ) salah dan pred( b, a ) salah, di mana pred adalah predikat yang ditentukan parameter. partition Algoritma tidak stabil dan tidak menjamin bahwa pengurutan relatif elemen yang setara akan dipertahankan. Algoritma stable_partition mempertahankan urutan asli ini.

Kompleksitasnya linier: ada (last - first) aplikasi dan paling banyak pred pertukaran(last - first)/2.

Contoh

// 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;
}

Vector v1 is ( 4 10 7 8 0 5 2 1 6 9 3 ).
The partitioned set of elements in v1 is: ( 9 10 7 8 6 5 2 1 0 4 3 ).

partition_copy

Menyalin elemen yang kondisinya ke true satu tujuan, dan yang kondisinya false lain. Elemen harus berasal dari rentang yang ditentukan.

template<class InputIterator, class OutputIterator1, class OutputIterator2, class UnaryPredicate>
pair<OutputIterator1, OutputIterator2> partition_copy(
    InputIterator first,
    InputIterator last,
    OutputIterator1 dest1,
    OutputIterator2 dest2,
    UnaryPredicate pred);

template <class ExecutionPolicy, class ForwardIterator, class ForwardIterator1, class ForwardIterator2, class UnaryPredicate>
pair<ForwardIterator1, ForwardIterator2> partition_copy(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    ForwardIterator1 out_true,
    ForwardIterator2 out_false,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjukkan awal rentang untuk memeriksa kondisi.

last
Iterator input yang menunjukkan akhir rentang.

dest1
Iterator output yang digunakan untuk menyalin elemen yang mengembalikan true untuk kondisi yang diuji dengan menggunakan pred.

dest2
Iterator output yang digunakan untuk menyalin elemen yang mengembalikan false untuk kondisi yang diuji dengan menggunakan pred.

pred
Kondisi untuk diuji. Pengujian disediakan oleh objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan diuji. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Keterangan

Fungsi templat menyalin setiap elemen X ke [first,last)*dest1++ jika pred(X) benar, atau jika *dest2++ tidak. Hal ini mengembalikan pair<OutputIterator1, OutputIterator2>(dest1, dest2).

partition_point

Mengembalikan elemen pertama dalam rentang yang diberikan yang tidak memenuhi kondisi. Elemen diurutkan sehingga yang memenuhi kondisi datang sebelum yang tidak.

template<class ForwardIterator, class UnaryPredicate>
ForwardIterator partition_point(
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

first
ForwardIterator Yang menunjukkan awal rentang untuk memeriksa kondisi.

last
ForwardIterator Yang menunjukkan akhir rentang.

pred
Kondisi untuk diuji. Pengujian disediakan oleh objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang harus dipenuhi oleh elemen yang sedang dicari. Predikat unary mengambil satu argumen dan mengembalikan true atau false.

Nilai hasil

ForwardIterator Mengembalikan yang mengacu pada elemen pertama yang tidak memenuhi kondisi yang diuji oleh pred, atau mengembalikan last jika tidak ditemukan.

Keterangan

Fungsi templat menemukan iterator it pertama di [first, last) mana pred(*it) adalah false. Urutan harus diurutkan oleh pred.

pop_heap

Menghapus elemen terbesar dari depan timbunan ke posisi berikutnya ke yang terakhir dalam rentang dan kemudian membentuk timbunan baru dari elemen yang tersisa.

template<class RandomAccessIterator>
void pop_heap(
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class RandomAccessIterator, class BinaryPredicate>
void pop_heap(
    RandomAccessIterator first,
    RandomAccessIterator last,
    BinaryPredicate pred);

Parameter

first
Iterator akses acak yang mengatasi posisi elemen pertama dalam timbunan.

last
Iterator akses acak yang mengatasi posisi satu melewati elemen akhir dalam timbunan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

pop_heap Algoritma adalah inversi dari operasi yang dilakukan oleh algoritma push_heap, di mana elemen pada posisi rentang berikutnya ke yang terakhir ditambahkan ke timbunan yang terdiri dari elemen sebelumnya dalam rentang, dalam kasus ketika elemen yang ditambahkan ke tumpukan lebih besar dari elemen yang sudah ada di tumpukan.

Timbunan memiliki dua properti:

• Elemen pertama selalu yang terbesar.

• Elemen dapat ditambahkan atau dihapus dalam waktu logaritmik.

Tumpukan adalah cara ideal untuk menerapkan antrean prioritas dan digunakan dalam implementasi adaptor kontainer C++ Standard Library priority_queue Class.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang yang tidak termasuk elemen yang baru ditambahkan di akhir harus berupa timbunan.

Kompleksitasnya adalah logaritma, membutuhkan sebagian besar log (last - first) perbandingan.

Contoh

// 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;
}

The heaped version of vector v1 is ( 9 7 8 5 1 6 3 2 4 ).
The reheaped v1 with 10 added is ( 10 9 8 5 7 6 3 2 4 1 ).
The heap v1 with 10 removed is ( 9 7 8 5 1 6 3 2 4 10 ).

The 'greater than' reheaped v1 puts the smallest element first:
 ( 0 1 3 4 2 6 8 5 9 10 7 ).
The 'greater than' heaped v1 with the smallest element
 removed from the heap is: ( 1 2 3 4 7 6 8 5 9 10 0 ).

prev_permutation

Menyusun ulang elemen dalam rentang sehingga urutan asli digantikan oleh permutasi yang lebih besar sebelumnya secara leksikografis jika ada. Predikat biner dapat menentukan rasa leksikografis sebelumnya.

template<class BidirectionalIterator>
bool prev_permutation(
    BidirectionalIterator first,
    BidirectionalIterator last);

template<class BidirectionalIterator, class BinaryPredicate>
bool prev_permutation(
    BidirectionalIterator first,
    BidirectionalIterator last,
    BinaryPredicate pred);

Parameter

first
Iterator dua arah yang menunjuk ke posisi elemen pertama dalam rentang yang akan dialihkan.

last
Iterator dua arah yang menunjuk ke posisi satu melewati elemen akhir dalam rentang yang akan dialihkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

true jika permutasi sebelumnya secara leksikografis ada dan telah menggantikan urutan asli rentang; jika tidak false, dalam hal ini pemesanan diubah menjadi permutasi terbesar secara leksikografis.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Predikat biner default kurang dari dan elemen dalam rentang harus kurang dari sebanding untuk memastikan bahwa permutasi sebelumnya didefinisikan dengan baik.

Kompleksitasnya linier, dengan paling banyak (last - first)/2 pertukaran.

Contoh

// 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

Menambahkan elemen yang berada di akhir rentang ke timbunan yang ada yang terdiri dari elemen sebelumnya dalam rentang.

template<class RandomAccessIterator>
void push_heap(
    RandomAccessIterator first,
    RandomAccessIterator last );

template<class RandomAccessIterator, class BinaryPredicate>
void push_heap(
    RandomAccessIterator first,
    RandomAccessIterator last,
    BinaryPredicate pred);

Parameter

first
Iterator akses acak yang mengatasi posisi elemen pertama dalam timbunan.

last
Iterator akses acak yang membahas posisi satu melewati elemen akhir dalam rentang untuk dikonversi menjadi tumpukan.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

Elemen harus terlebih dahulu didorong kembali ke akhir timbunan yang ada dan kemudian algoritma digunakan untuk menambahkan elemen ini ke tumpukan yang ada.

Timbunan memiliki dua properti:

• Elemen pertama selalu yang terbesar.

• Elemen dapat ditambahkan atau dihapus dalam waktu logaritmik.

Tumpukan adalah cara ideal untuk menerapkan antrean prioritas dan digunakan dalam implementasi adaptor kontainer C++ Standard Library priority_queue Class.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang yang tidak termasuk elemen yang baru ditambahkan di akhir harus berupa timbunan.

Kompleksitasnya adalah logaritma, membutuhkan sebagian besar log(last - first) perbandingan.

Contoh

// 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;
}

Vector v1 is ( 5 4 8 9 1 6 3 2 7 ).
The heaped version of vector v1 is ( 9 7 8 5 1 6 3 2 4 ).
The heap v1 with 10 pushed back is ( 9 7 8 5 1 6 3 2 4 10 ).
The reheaped v1 with 10 added is ( 10 9 8 5 7 6 3 2 4 1 ).

The greater-than heaped version of v1 is
 ( 1 2 3 4 7 6 8 5 10 9 ).
The greater-than heap v1 with 11 pushed back is
 ( 1 2 3 4 7 6 8 5 10 9 0 ).
The greater than reheaped v1 with 11 added is
 ( 0 1 3 4 2 6 8 5 10 9 7 ).

random_shuffle

Fungsi std::random_shuffle() tidak digunakan lagi, digantikan oleh std::shuffle. Untuk contoh kode dan informasi selengkapnya, lihat <random> dan posting Stack Overflow Mengapa std::random_shuffle metode tidak digunakan lagi di C++14?.

remove

Menghilangkan nilai tertentu dari rentang tertentu tanpa mengganggu urutan elemen yang tersisa. Mengembalikan akhir rentang baru yang bebas dari nilai yang ditentukan.

template<class ForwardIterator, class Type>
ForwardIterator remove(
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class Type>
ForwardIterator remove(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang membahas posisi elemen pertama dalam rentang tempat elemen dihapus.

last
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang dari elemen mana yang dihapus.

value
Nilai yang akan dihapus dari rentang.

Nilai hasil

Iterator penerusan yang membahas posisi akhir baru dari rentang yang dimodifikasi, satu melewati elemen akhir dari urutan remnant bebas dari nilai yang ditentukan.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Urutan elemen yang tidak dihapus tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan.

list ini memiliki versi fungsi anggota yang lebih efisien dari remove, yang juga menautkan kembali penunjuk.

Contoh

// 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;
}

Vector v1 is ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
Vector v1 with value 7 removed is ( 4 0 5 1 6 9 3 8 2 9 3 7 8 2 ).
Vector v1 resized with value 7 removed is ( 4 0 5 1 6 9 3 8 2 ).

remove_copy

Menyalin elemen dari rentang sumber ke rentang tujuan, kecuali bahwa elemen dari nilai tertentu tidak disalin, tanpa mengganggu urutan elemen yang tersisa. Mengembalikan akhir rentang tujuan baru.

template<class InputIterator, class OutputIterator, class Type>
OutputIterator remove_copy(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
ForwardIterator2 remove_copy(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas posisi elemen pertama dalam rentang tempat elemen dihapus.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang dari elemen mana yang dihapus.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan tempat elemen dihapus.

value
Nilai yang akan dihapus dari rentang.

Nilai hasil

Iterator penerusan yang membahas posisi akhir baru rentang tujuan, satu melewati elemen akhir salinan urutan sisa bebas dari nilai yang ditentukan.

Keterangan

Rentang sumber dan tujuan yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Harus ada cukup ruang dalam rentang tujuan untuk berisi elemen sisa yang akan disalin setelah elemen dari nilai yang ditentukan dihapus.

Urutan elemen yang tidak dihapus tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan dan paling banyak (last - first) penugasan.

Contoh

// 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;
}

The original vector v1 is:     ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
Vector v1 is left unchanged as ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
Vector v2 is a copy of v1 with the value 7 removed:
 ( 4 0 5 1 6 9 3 8 2 0 ).

remove_copy_if

Menyalin elemen dari rentang sumber ke rentang tujuan, kecuali untuk elemen yang memenuhi predikat. Elemen disalin tanpa mengganggu urutan elemen yang tersisa. Mengembalikan akhir rentang tujuan baru.

template<class InputIterator, class OutputIterator, class UnaryPredicate>
OutputIterator remove_copy_if(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class UnaryPredicate>
ForwardIterator2 remove_copy_if(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas posisi elemen pertama dalam rentang tempat elemen dihapus.

last
Iterator input yang membahas posisi satu melewati elemen akhir dalam rentang dari elemen mana yang dihapus.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan tempat elemen dihapus.

pred
Predikat unary yang harus dipenuhi adalah nilai elemen yang akan diganti.

Nilai hasil

Iterator penerusan yang membahas posisi akhir baru rentang tujuan, satu melewati elemen akhir dari urutan sisa bebas dari elemen yang memenuhi predikat.

Keterangan

Rentang sumber yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Harus ada cukup ruang dalam rentang tujuan untuk berisi elemen sisa yang akan disalin setelah elemen dari nilai yang ditentukan dihapus.

Urutan elemen yang tidak dihapus tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan dan paling banyak (last - first) penugasan.

Untuk informasi tentang bagaimana fungsi-fungsi ini berperilaku, lihat Iterator yang Diperiksa.

Contoh

// 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;
}

The original vector v1 is:      ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
After the appliation of remove_copy_if to v1,
 vector v1 is left unchanged as ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
Vector v2 is a copy of v1 with values greater than 6 removed:
 ( 4 0 5 1 6 3 2 ).

remove_if

Menghilangkan elemen yang memenuhi predikat dari rentang tertentu tanpa mengganggu urutan elemen yang tersisa. Mengembalikan akhir rentang baru yang bebas dari nilai yang ditentukan.

template<class ForwardIterator, class UnaryPredicate>
ForwardIterator remove_if(
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class UnaryPredicate>
ForwardIterator remove_if(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menunjuk ke posisi elemen pertama dalam rentang dari mana elemen dihapus.

last
Iterator maju yang menunjuk ke posisi satu melewati elemen akhir dalam rentang dari elemen mana yang dihapus.

pred
Predikat unary yang harus dipenuhi adalah nilai elemen yang akan diganti.

Nilai hasil

Iterator penerusan yang membahas posisi akhir baru dari rentang yang dimodifikasi, satu melewati elemen akhir dari urutan remnant bebas dari nilai yang ditentukan.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Urutan elemen yang tidak dihapus tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan.

Daftar memiliki versi fungsi anggota yang lebih efisien untuk menghapus penunjuk tautan ulang mana.

Contoh

// 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;
}

Vector v1 is ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
Vector v1 with elements satisfying greater6 removed is
 ( 4 0 5 1 6 3 2 1 6 9 3 7 8 2 ).
Vector v1 resized elements satisfying greater6 removed is
 ( 4 0 5 1 6 3 2 ).

replace

Memeriksa setiap elemen dalam rentang dan menggantinya jika cocok dengan nilai yang ditentukan.

template<class ForwardIterator, class Type>
void replace(
    ForwardIterator first,
    ForwardIterator last,
    const Type& oldVal,
    const Type& newVal);

template<class ExecutionPolicy, class ForwardIterator, class Type>
void replace(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    const Type& oldVal,
    const Type& newVal);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menunjuk ke posisi elemen pertama dalam rentang dari elemen mana yang diganti.

last
Iterator maju yang menunjuk ke posisi satu melewati elemen akhir dalam rentang dari mana elemen diganti.

oldVal
Nilai lama elemen yang diganti.

newVal
Nilai baru ditetapkan ke elemen dengan nilai lama.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Urutan elemen yang tidak diganti tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan dan paling banyak (last - first) penetapan nilai baru.

Contoh

// alg_replace.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>

int main()
{
    std::vector<int> v;

    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    for (int i = 0; i < 3; i++)
    {
        v.push_back(7);
    }

    std::cout << "The original vector v is:\n ( ";
    for (auto iter = v.begin(); iter != v.end(); iter++)
    {
        std::cout << *iter << " ";
    }
    std::cout << ")." << std::endl;

    // Replace elements with a value of 7 with a value of 700
    replace(v.begin(), v.end(), 7, 700);

    std::cout << "The vector v with 7s replaced with 700s:\n ( ";
    for (auto iter = v.begin(); iter != v.end(); iter++)
    {
        std::cout << *iter << " ";
    }
    std::cout << ")." << std::endl;
}

The original vector v is:
 ( 0 1 2 3 4 5 6 7 8 9 7 7 7 ).
The vector v with 7s replaced with 700s:
 ( 0 1 2 3 4 5 6 700 8 9 700 700 700 ).

replace_copy

Memeriksa setiap elemen dalam rentang sumber dan menggantinya jika cocok dengan nilai yang ditentukan saat menyalin hasilnya ke rentang tujuan baru.

template<class InputIterator, class OutputIterator, class Type>
OutputIterator replace_copy(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    const Type& oldVal,
    const Type& newVal);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
ForwardIterator2 replace_copy(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    const Type& oldVal,
    const Type& newVal);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjuk ke posisi elemen pertama dalam rentang dari elemen mana yang diganti.

last
Iterator input yang menunjuk ke posisi satu melewati elemen akhir dalam rentang dari elemen mana yang diganti.

result
Iterator output yang menunjuk ke elemen pertama dalam rentang tujuan ke tempat urutan elemen yang diubah sedang disalin.

oldVal
Nilai lama elemen yang diganti.

newVal
Nilai baru ditetapkan ke elemen dengan nilai lama.

Nilai hasil

Iterator output yang menunjuk ke posisi satu melewati elemen akhir dalam rentang tujuan urutan elemen yang diubah disalin.

Keterangan

Rentang sumber dan tujuan yang direferensikan tidak boleh tumpang tindih dan keduanya harus valid: semua penunjuk harus dapat diturunkan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Urutan elemen yang tidak diganti tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan dan paling banyak (last - first) penetapan nilai baru.

Contoh

// alg_replace_copy.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> theVector;
    list<int> theList(15);

    for (int i = 0; i <= 9; i++)
    {
        theVector.push_back(i);
    }

    for (int i = 0; i <= 3; i++)
    {
        theVector.push_back(7);
    }

    random_shuffle(theVector.begin(), theVector.end());
	
    for (int i = 0; i <= 15; i++)
    {
        theVector.push_back(1);
    }

    cout << "The shuffled vector:\n ( ";
    for (auto iter = theVector.begin(); iter != theVector.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;

    // Replace the 7s in part of the vector with 70s
    // and copy into another part of the vector
    replace_copy(theVector.begin(), theVector.begin() + 14, theVector.end() - 15, 7, 70);

    cout << "The vector with instances of 7 replaced with 70 starting at position 14:\n ( ";
    for (auto iter = theVector.begin(); iter != theVector.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;

    // Replace 7s found in the first 14 positions in the vector with 1s and then copy the result into a list
    replace_copy(theVector.begin(), theVector.begin() + 14, theList.begin(), 7, 1);

    cout << "List containing the contents of the vector but 7s replaced with 1s.\n ( ";
    for (auto iter = theList.begin(); iter != theList.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;
}

random_shuffle() Karena panggilan dalam kode sebelumnya, output Anda mungkin berbeda.

The shuffled vector:
 ( 7 1 9 2 0 7 7 3 4 6 8 5 7 7 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ).
The vector with instances of 7 replaced with 70 starting at position 14:
 ( 7 1 9 2 0 7 7 3 4 6 8 5 7 7 1 70 1 9 2 0 70 70 3 4 6 8 5 70 70 1 ).
List containing the contents of the vector but 7s replaced with 1s.
 ( 1 1 9 2 0 1 1 3 4 6 8 5 1 1 0 ).

replace_copy_if

Memeriksa setiap elemen dalam rentang sumber dan menggantinya jika memenuhi predikat yang ditentukan saat menyalin hasilnya ke dalam rentang tujuan baru.

template<class InputIterator, class OutputIterator, class UnaryPredicate, class Type>
OutputIterator replace_copy_if(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    UnaryPredicate pred,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class UnaryPredicate, class Type>
ForwardIterator2 replace_copy_if(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    UnaryPredicate pred,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menunjuk ke posisi elemen pertama dalam rentang dari elemen mana yang diganti.

last
Iterator input yang menunjuk ke posisi satu melewati elemen akhir dalam rentang dari elemen mana yang diganti.

result
Iterator output yang menunjuk ke posisi elemen pertama dalam rentang tujuan tempat elemen sedang disalin.

pred
Predikat unary yang harus dipenuhi adalah nilai elemen yang akan diganti.

value
Nilai baru ditetapkan ke elemen yang nilai lamanya memenuhi predikat.

Nilai hasil

Iterator output yang menunjuk ke posisi satu melewati elemen akhir dalam rentang tujuan urutan elemen yang diubah disalin.

Keterangan

Rentang sumber dan tujuan yang direferensikan tidak boleh tumpang tindih dan keduanya harus valid: semua penunjuk harus dapat diturunkan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Urutan elemen yang tidak diganti tetap stabil.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan dan paling banyak (last - first) penetapan nilai baru.

Contoh

// 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;
}

The original vector v1 is:
 ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
The vector v1 with values of 70 replacing those greater
 than 6 in the 1st half & copied into the 2nd half is:
 ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).
A list copy of vector v1 with the value -1
 replacing those greater than 6 is:
 ( 4 7 7 7 0 5 7 1 6 9 3 7 8 2 ).

replace_if

Memeriksa setiap elemen dalam rentang dan menggantinya jika memenuhi predikat yang ditentukan.

template<class ForwardIterator, class UnaryPredicate, class Type>
void replace_if(
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class UnaryPredicate, class Type>
void replace_if(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    UnaryPredicate pred,
    const Type& value);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menunjuk ke posisi elemen pertama dalam rentang dari elemen mana yang diganti.

last
Iterator yang menunjuk ke posisi satu melewati elemen akhir dalam rentang dari elemen mana yang diganti.

pred
Predikat unary yang harus dipenuhi adalah nilai elemen yang akan diganti.

value
Nilai baru ditetapkan ke elemen yang nilai lamanya memenuhi predikat.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Urutan elemen yang tidak diganti tetap stabil.

Algoritma replace_if adalah generalisasi algoritma replace, memungkinkan predikat apa pun ditentukan, daripada kesetaraan dengan nilai konstanta tertentu.

yang operator== digunakan untuk menentukan kesetaraan antara elemen harus memaksakan hubungan kesetaraan antara operannya.

Kompleksitasnya linier. Ini membuat (last - first) perbandingan untuk kesetaraan dan paling banyak (last - first) penetapan nilai baru.

Contoh

// 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> v;

    for (int i = 0; i <= 10; i++)
    {
        v.push_back(i);
    }

    cout << "The original vector v:\n ( ";
    for (auto iter = v.begin(); iter != v.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;

    // Replace elements satisfying the predicate greater6
    // with a value of 70
    replace_if(v.begin(), v.end(), greater6, 70);

    cout << "The vector v with a value 70 replacing those\n "
        << "elements satisfying the greater6 predicate is:\n ( ";
    for (auto iter = v.begin(); iter != v.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ").";
}

The original vector v:
 ( 0 1 2 3 4 5 6 7 8 9 10 ).
The vector v with a value 70 replacing those
 elements satisfying the greater6 predicate is:
 ( 0 1 2 3 4 5 6 70 70 70 70 ).

reverse

Membalikkan urutan elemen dalam rentang.

template<class BidirectionalIterator>
void reverse(
    BidirectionalIterator first,
    BidirectionalIterator last);

template<class ExecutionPolicy, class BidirectionalIterator>
void reverse(
    ExecutionPolicy&& exec,
    BidirectionalIterator first,
    BidirectionalIterator last);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator dua arah yang menunjuk ke posisi elemen pertama dalam rentang di mana elemen disebarkan.

last
Iterator dua arah yang menunjuk ke posisi satu melewati elemen akhir dalam rentang tempat elemen dialihkan.

Keterangan

Rentang sumber yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Contoh

// 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

Membalikkan urutan elemen dalam rentang sumber saat menyalinnya ke dalam rentang tujuan

template<class BidirectionalIterator, class OutputIterator>
OutputIterator reverse_copy(
    BidirectionalIterator first,
    BidirectionalIterator last,
    OutputIterator result);

template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
ForwardIterator reverse_copy(
    ExecutionPolicy&& exec,
    BidirectionalIterator first,
    BidirectionalIterator last,
    ForwardIterator result);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator dua arah yang menunjuk ke posisi elemen pertama dalam rentang sumber di mana elemen dialihkan.

last
Iterator dua arah yang menunjuk ke posisi satu melewati elemen akhir dalam rentang sumber tempat elemen dirujuk.

result
Iterator output yang menunjuk ke posisi elemen pertama dalam rentang tujuan tempat elemen sedang disalin.

Nilai hasil

Iterator output yang menunjuk ke posisi satu melewati elemen akhir dalam rentang tujuan urutan elemen yang diubah disalin.

Keterangan

Rentang sumber dan tujuan yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Contoh

// 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;
}

The original vector v1 is:
 ( 0 1 2 3 4 5 6 7 8 9 ).
The copy v2 of the reversed vector v1 is:
 ( 9 8 7 6 5 4 3 2 1 0 ).
The original vector v1 remains unmodified as:
 ( 0 1 2 3 4 5 6 7 8 9 ).

rotate

Menukar elemen dalam dua rentang yang berdekatan.

template<class ForwardIterator>
void rotate(
    ForwardIterator first,
    ForwardIterator middle,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator rotate(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator middle,
    ForwardIterator last);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator maju yang membahas posisi elemen pertama dalam rentang yang akan diputar.

middle
Iterator maju yang menentukan batas dalam rentang yang membahas posisi elemen pertama di bagian kedua dari rentang yang elemennya akan ditukar dengan yang ada di bagian pertama rentang.

last
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan diputar.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier. Ini membuat paling banyak (last - first) pertukaran.

Contoh

// 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

Menukar elemen dalam dua rentang yang berdekatan dalam rentang sumber dan menyalin hasilnya ke rentang tujuan.

template<class ForwardIterator, class OutputIterator>
OutputIterator rotate_copy(
    ForwardIterator first,
    ForwardIterator middle,
    ForwardIterator last,
    OutputIterator result );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 rotate_copy(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 middle,
    ForwardIterator1 last,
    ForwardIterator2 result);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator maju yang membahas posisi elemen pertama dalam rentang yang akan diputar.

middle
Iterator maju yang menentukan batas dalam rentang yang membahas posisi elemen pertama di bagian kedua dari rentang yang elemennya akan ditukar dengan yang ada di bagian pertama rentang.

last
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan diputar.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan.

Nilai hasil

Iterator output yang mengatasi posisi satu melewati elemen akhir dalam rentang tujuan.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier. Ini membuat paling banyak (last - first) pertukaran.

Contoh

// 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++;
    }
}

Vector v1 is ( -3 -2 -1 0 1 2 3 4 5 ).
After rotating, the vector v1 remains unchanged as:
 v1 = ( -3 -2 -1 0 1 2 3 4 5 ).
After rotating, the copy of vector v1 in v2 is:
 v2 = ( 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,
 d2 is   ( 1 2 3 4 5 0 ).
After the rotation of a single deque element to the back,
 d2 is   ( 2 3 4 5 0 1 ).
After the rotation of a single deque element to the back,
 d2 is   ( 3 4 5 0 1 2 ).
After the rotation of a single deque element to the back,
 d2 is   ( 4 5 0 1 2 3 ).
After the rotation of a single deque element to the back,
 d2 is   ( 5 0 1 2 3 4 ).
After the rotation of a single deque element to the back,
 d2 is   ( 0 1 2 3 4 5 ).

sample

template<class PopulationIterator, class SampleIterator, class Distance, class UniformRandomBitGenerator>
SampleIterator sample(
    PopulationIterator first,
    PopulationIterator last,
    SampleIterator out,
    Distance n,
    UniformRandomBitGenerator&& g);

search

Mencari kemunculan pertama urutan dalam rentang target yang elemennya sama dengan elemen dalam urutan elemen tertentu atau yang elemennya setara dalam arti yang ditentukan oleh predikat biner ke elemen dalam urutan tertentu.

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 search(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 search(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    BinaryPredicate pred);

template <class ForwardIterator, class Searcher>
ForwardIterator search(
    ForwardIterator first,
    ForwardIterator last,
    const Searcher& searcher);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last1
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

first2
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicocokkan.

last2
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicocokkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

searcher
Pencari yang merangkum pola yang akan dicari dan algoritma pencarian yang akan digunakan. Untuk informasi selengkapnya tentang pencari, lihat default_searcher kelas, boyer_moore_horspool_searcher kelas, dan boyer_moore_searcher kelas.

Nilai hasil

Iterator penerusan yang membahas posisi elemen pertama dari subsekuensi pertama yang cocok dengan urutan yang ditentukan atau yang setara dalam arti yang ditentukan oleh predikat biner.

Keterangan

yang operator== digunakan untuk menentukan kecocokan antara elemen dan nilai yang ditentukan harus memaksakan hubungan kesetaraan antara operannya.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitas rata-rata linier sehubungan dengan ukuran rentang yang dicari. Kompleksitas kasus terburuk juga linier sehubungan dengan ukuran urutan yang dicari.

Contoh

// 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

Mencari subsekuensi pertama dalam rentang dari sejumlah elemen tertentu yang memiliki nilai tertentu atau hubungan dengan nilai tersebut sebagaimana ditentukan oleh predikat biner.

template<class ForwardIterator1, class Diff2, class Type>
ForwardIterator1 search_n(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    Diff2 count,
    const Type& value);

template<class ForwardIterator1, class Diff2, class Type, class BinaryPredicate>
ForwardIterator1 search_n(
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    Diff2 count,
    const Type& value,
    BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Type>
ForwardIterator search_n(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Size count,
    const Type& value);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Type, class BinaryPredicate>
ForwardIterator search_n(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Size count,
    const Type& value,
    BinaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dicari.

last1
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dicari.

count
Ukuran berikutnya yang sedang dicari.

value
Nilai elemen dalam urutan yang sedang dicari.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator penerusan yang membahas posisi elemen pertama dari subsekuensi pertama yang cocok dengan urutan yang ditentukan atau yang setara dalam arti yang ditentukan oleh predikat biner.

Keterangan

yang operator== digunakan untuk menentukan kecocokan antara elemen dan nilai yang ditentukan harus memaksakan hubungan kesetaraan antara operannya.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitas linier sehubungan dengan ukuran yang dicari.

Contoh

// 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

Menyatukan semua elemen yang termasuk dalam satu rentang sumber yang diurutkan, tetapi tidak ke rentang sumber kedua yang diurutkan, ke dalam satu rentang tujuan yang diurutkan. Predikat biner dapat menentukan kriteria pemesanan.

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 Compare>
OutputIterator set_difference(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator>
ForwardIterator set_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare>
ForwardIterator set_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan dari dua rentang sumber.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir di yang pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan dari dua rentang sumber.

first2
Iterator input yang membahas posisi elemen pertama dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan dari dua rentang sumber.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan dari dua rentang sumber.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan di mana kedua rentang sumber akan disatukan ke dalam satu rentang yang diurutkan yang mewakili perbedaan dari dua rentang sumber.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua dan false sebaliknya.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen terakhir dalam rentang tujuan yang diurutkan mewakili perbedaan dari dua rentang sumber.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang tujuan tidak boleh tumpang tindih dengan salah satu rentang sumber dan harus cukup besar untuk berisi rentang sumber pertama.

Rentang sumber yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi set_difference algoritma sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Operasi stabil karena urutan relatif elemen dalam setiap rentang dipertahankan dalam rentang tujuan. Rentang sumber tidak dimodifikasi oleh penggabungan algoritma.

Jenis nilai iterator input harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara. Ketika ada elemen yang setara di kedua rentang sumber, elemen dalam rentang pertama mendahului elemen dari rentang sumber kedua dalam rentang tujuan. Jika rentang sumber berisi duplikat elemen sehingga ada lebih banyak di rentang sumber pertama daripada di yang kedua, maka rentang tujuan akan berisi angka di mana kemunculan elemen-elemen tersebut dalam rentang sumber pertama melebihi kemunculan elemen-elemen tersebut dalam rentang sumber kedua.

Kompleksitas algoritma linier dengan paling banyak 2 * ((last1 - first1) + (last2 - first2)) - 1 perbandingan untuk rentang sumber yang tidak ada.

Contoh

// 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;
}

Original vector v1a with range sorted by the
 binary predicate less than is v1a = ( -1 0 1 2 3 4 ).
Original vector v1b with range sorted by the
 binary predicate less than is v1b = ( -3 -2 -1 0 ).
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 = ( 0 -1 -2 -3 ).
Original vector v3a with range sorted by the
 binary predicate mod_lesser is   v3a = ( 0 -1 1 2 3 4 ).
Original vector v3b with range sorted by the
 binary predicate mod_lesser is   v3b = ( 0 -1 -2 -3 ).
Set_difference of source ranges with default order,
 vector v1mod = ( 1 2 3 4 ).
Set_difference of source ranges with binarypredicate greater specified,
 vector v2mod = ( 4 3 2 1 ).
Set_difference of source ranges with binary predicate mod_lesser specified,
 vector v3mod = ( 1 4 ).

set_intersection

Menyatukan semua elemen yang termasuk dalam kedua rentang sumber yang diurutkan ke dalam satu rentang tujuan yang diurutkan, di mana kriteria pengurutan dapat ditentukan oleh predikat biner.

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_intersection(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result,
    Compare pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator>
ForwardIterator set_intersection(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare>
ForwardIterator set_intersection(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili persimpangan dari dua rentang sumber.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili persimpangan dari dua rentang sumber.

first2
Iterator input yang membahas posisi elemen pertama dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili persimpangan dari dua rentang sumber.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili persimpangan dari dua rentang sumber.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan di mana kedua rentang sumber akan disatukan ke dalam satu rentang yang diurutkan yang mewakili persimpangan dari dua rentang sumber.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua dan false sebaliknya.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen terakhir dalam rentang tujuan yang diurutkan mewakili persimpangan dari dua rentang sumber.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang tujuan tidak boleh tumpang tindih dengan salah satu rentang sumber dan harus cukup besar untuk berisi rentang tujuan.

Rentang sumber yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi algoritma penggabungan sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Operasi stabil karena urutan relatif elemen dalam setiap rentang dipertahankan dalam rentang tujuan. Rentang sumber tidak dimodifikasi oleh algoritma.

Jenis nilai iterator input harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara. Ketika ada elemen yang setara di kedua rentang sumber, elemen dalam rentang pertama mendahului elemen dari rentang sumber kedua dalam rentang tujuan. Jika rentang sumber berisi duplikat elemen, maka rentang tujuan akan berisi jumlah maksimum elemen yang terjadi di kedua rentang sumber.

Kompleksitas algoritma linier dengan paling banyak 2 * ((last1 - first1) + (last2 - first2)) - 1 perbandingan untuk rentang sumber yang tidak ada.

Contoh

// 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;
}

Original vector v1a with range sorted by the
 binary predicate less than is v1a = ( -1 0 1 2 3 ).
Original vector v1b with range sorted by the
 binary predicate less than is v1b = ( -3 -2 -1 0 1 ).
Original vector v2a with range sorted by the
 binary predicate greater is   v2a = ( 3 2 1 0 -1 ).
Original vector v2b with range sorted by the
 binary predicate greater is   v2b = ( 1 0 -1 -2 -3 ).
Original vector v3a with range sorted by the
 binary predicate mod_lesser is   v3a = ( 0 -1 1 2 3 ).
Original vector v3b with range sorted by the
 binary predicate mod_lesser is   v3b = ( 0 -1 1 -2 -3 ).
Intersection of source ranges with default order,
 vector v1mod = ( -1 0 1 ).
Intersection of source ranges with binary predicate greater specified,
 vector v2mod = ( 1 0 -1 ).
Intersection of source ranges with binary predicate mod_lesser specified,
 vector v3mod = ( 0 -1 1 2 3 ).

set_symmetric_difference

Menyatukan semua elemen yang termasuk dalam salah satu elemen, tetapi tidak keduanya, dari rentang sumber yang diurutkan ke dalam satu rentang tujuan yang diurutkan. Predikat biner dapat menentukan kriteria pemesanan.

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_symmetric_difference(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result );

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_symmetric_difference(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator>
ForwardIterator set_symmetric_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare>
ForwardIterator set_symmetric_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan simetris dari dua rentang sumber.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan simetris dari dua rentang sumber.

first2
Iterator input yang membahas posisi elemen pertama dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan simetris dari dua rentang sumber.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili perbedaan simetris dari dua rentang sumber.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan di mana kedua rentang sumber akan disatukan ke dalam satu rentang yang diurutkan yang mewakili perbedaan simetris dari dua rentang sumber.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua dan false sebaliknya.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen terakhir dalam rentang tujuan yang diurutkan mewakili perbedaan simetris dari dua rentang sumber.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang tujuan tidak boleh tumpang tindih dengan salah satu rentang sumber dan harus cukup besar untuk berisi rentang tujuan.

Rentang sumber yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi merge* algoritma sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Operasi stabil karena urutan relatif elemen dalam setiap rentang dipertahankan dalam rentang tujuan. Rentang sumber tidak dimodifikasi oleh penggabungan algoritma.

Jenis nilai iterator input harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara. Ketika ada elemen yang setara di kedua rentang sumber, elemen dalam rentang pertama mendahului elemen dari rentang sumber kedua dalam rentang tujuan. Jika rentang sumber berisi duplikat elemen, maka rentang tujuan akan berisi nilai absolut angka di mana kemunculan elemen-elemen tersebut di salah satu rentang sumber melebihi kemunculan elemen tersebut dalam rentang sumber kedua.

Kompleksitas algoritma linier dengan paling banyak 2 * ((last1 - first1) + (last2 - first2)) - 1 perbandingan untuk rentang sumber yang tidak ada.

Contoh

// 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;
}

Original vector v1a with range sorted by the
 binary predicate less than is v1a = ( -1 0 1 2 3 4 ).
Original vector v1b with range sorted by the
 binary predicate less than is v1b = ( -3 -2 -1 0 ).
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 = ( 0 -1 -2 -3 ).
Original vector v3a with range sorted by the
 binary predicate mod_lesser is   v3a = ( 0 -1 1 2 3 4 ).
Original vector v3b with range sorted by the
 binary predicate mod_lesser is   v3b = ( 0 -1 -2 -3 ).
Set_symmetric_difference of source ranges with default order,
 vector v1mod = ( -3 -2 1 2 3 4 ).
Set_symmetric_difference of source ranges with binarypredicate greater specified,
 vector v2mod = ( 4 3 2 1 -2 -3 ).
Set_symmetric_difference of source ranges with binary predicate mod_lesser specified,
 vector v3mod = ( 1 4 ).

set_union

Menyatukan semua elemen yang termasuk dalam setidaknya satu dari dua rentang sumber yang diurutkan ke dalam satu rentang tujuan yang diurutkan. Predikat biner dapat menentukan kriteria pemesanan.

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_union(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result );

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
OutputIterator set_union(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    InputIterator2 last2,
    OutputIterator result,
    Compare pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator>
ForwardIterator set_union(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class Compare>
ForwardIterator set_union(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator2 last2,
    ForwardIterator result,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili gabungan dari dua rentang sumber.

last1
Iterator input yang membahas posisi satu melewati elemen terakhir di rentang sumber pertama dari dua rentang sumber yang diurutkan untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili gabungan dari dua rentang sumber.

first2
Iterator input yang membahas posisi elemen pertama dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili gabungan dari dua rentang sumber.

last2
Iterator input yang membahas posisi satu melewati elemen terakhir dalam detik dari dua rentang sumber yang diurutkan berturut-turut untuk disatukan dan diurutkan ke dalam satu rentang yang mewakili gabungan dari dua rentang sumber.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan di mana dua rentang sumber akan disatukan ke dalam satu rentang yang diurutkan yang mewakili gabungan dari dua rentang sumber.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat biner mengambil dua argumen dan harus kembali true ketika elemen pertama kurang dari elemen kedua dan false sebaliknya.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen terakhir dalam rentang tujuan yang diurutkan yang mewakili gabungan dari dua rentang sumber.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang tujuan tidak boleh tumpang tindih dengan salah satu rentang sumber dan harus cukup besar untuk berisi rentang tujuan.

Rentang sumber yang diurutkan masing-masing harus diatur sebagai prasyarat ke aplikasi merge algoritma sesuai dengan urutan yang sama seperti yang akan digunakan oleh algoritma untuk mengurutkan rentang gabungan.

Operasi stabil karena urutan relatif elemen dalam setiap rentang dipertahankan dalam rentang tujuan. Rentang sumber tidak dimodifikasi oleh algoritma merge.

Jenis nilai iterator input harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara. Ketika ada elemen yang setara di kedua rentang sumber, elemen dalam rentang pertama mendahului elemen dari rentang sumber kedua dalam rentang tujuan. Jika rentang sumber berisi duplikat elemen, maka rentang tujuan akan berisi jumlah maksimum elemen yang terjadi di kedua rentang sumber.

Kompleksitas algoritma linier dengan paling banyak 2 * ((last1 - first1) + (last2 - first2)) - 1 perbandingan.

Contoh

// 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;
}

Original vector v1a with range sorted by the
 binary predicate less than is v1a = ( -1 0 1 2 3 ).
Original vector v1b with range sorted by the
 binary predicate less than is v1b = ( -3 -2 -1 0 1 ).
Original vector v2a with range sorted by the
 binary predicate greater is   v2a = ( 3 2 1 0 -1 ).
Original vector v2b with range sorted by the
 binary predicate greater is   v2b = ( 1 0 -1 -2 -3 ).
Original vector v3a with range sorted by the
 binary predicate mod_lesser is   v3a = ( 0 -1 1 2 3 ).
Original vector v3b with range sorted by the
 binary predicate mod_lesser is   v3b = ( 0 -1 1 -2 -3 ).
Union of source ranges with default order,
 vector v1mod = ( -3 -2 -1 0 1 2 3 ).
Union of source ranges with binary predicate greater specified,
 vector v2mod = ( 3 2 1 0 -1 -2 -3 ).
Union of source ranges with binary predicate mod_lesser specified,
 vector v3mod = ( 0 -1 1 2 3 ).

shuffle

Mengacak (mengatur ulang) elemen untuk rentang tertentu dengan menggunakan generator angka acak.

template<class RandomAccessIterator, class UniformRandomNumberGenerator>
void shuffle(
    RandomAccessIterator first,
    RandomAccessIterator last,
    UniformRandomNumberGenerator&& gen);

Parameter

first
Iterator ke elemen pertama dalam rentang yang akan diacak, inklusif. Harus memenuhi persyaratan RandomAccessIterator dan ValueSwappable.

last
Iterator ke elemen terakhir dalam rentang yang akan diacak, eksklusif. Harus memenuhi persyaratan RandomAccessIterator dan ValueSwappable.

gen
Generator angka acak yang shuffle() akan digunakan fungsi untuk operasi. Harus memenuhi persyaratan dari UniformRandomNumberGenerator.

Keterangan

Untuk informasi selengkapnya, dan sampel kode yang menggunakan shuffle(), lihat <random>.

sort

Mengatur elemen dalam rentang tertentu ke dalam urutan yang tidak menurun atau sesuai dengan kriteria pemesanan yang ditentukan oleh predikat biner.

template<class RandomAccessIterator>
void sort(
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
void sort(
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

template<class ExecutionPolicy, class RandomAccessIterator>
void sort(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void sort(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator akses acak yang mengatasi posisi elemen pertama dalam rentang yang akan diurutkan.

last
Iterator akses acak yang membahas posisi satu melewati elemen akhir dalam rentang yang akan diurutkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat biner ini mengambil dua argumen dan mengembalikan true jika dua argumen berurutan dan false sebaliknya. Fungsi komparator ini harus memberlakukan urutan lemah yang ketat pada pasangan elemen dari urutan. Untuk informasi selengkapnya, lihat Algoritma.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Elemen setara, tetapi belum tentu sama, jika tidak kurang dari yang lain. sort Algoritma tidak stabil dan tidak menjamin bahwa pengurutan relatif elemen yang setara akan dipertahankan. Algoritma stable_sort mempertahankan urutan asli ini.

Rata-rata kompleksitas sortir adalah O( N log N ), di mana = last - first.

Contoh

// 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

Mengonversi tumpukan menjadi rentang yang diurutkan.

template<class RandomAccessIterator>
void sort_heap(
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
void sort_heap(
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

Parameter

first
Iterator akses acak yang mengatasi posisi elemen pertama dalam timbunan target.

last
Iterator akses acak yang membahas posisi satu melewati elemen akhir dalam tumpukkan target.

pred
Objek fungsi predikat yang ditentukan pengguna yang mendefinisikan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

Timbunan memiliki dua properti:

• Elemen pertama selalu yang terbesar.

• Elemen dapat ditambahkan atau dihapus dalam waktu logaritmik.

Setelah aplikasi jika algoritma ini, rentang yang diterapkannya bukan lagi timbunan.

sort_heap bukan pengurutan yang stabil karena urutan relatif elemen yang setara belum tentu dipertahankan.

Tumpukan adalah cara ideal untuk menerapkan antrean prioritas dan digunakan dalam implementasi Kelas adaptor priority_queue kontainer Pustaka Standar C++.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitas paling banyak N log N, di mana = last - first.

Contoh

// 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);
}

Initially: ( 1 2 3 4 5 6 7 8 9 )
After random_shuffle: ( 5 4 8 9 1 6 3 2 7 )
     After make_heap: ( 9 7 8 5 1 6 3 2 4 )
     After sort_heap: ( 1 2 3 4 5 6 7 8 9 )
             After random_shuffle: ( 1 3 6 8 9 5 4 2 7 )
After make_heap with greater<int>: ( 1 2 4 3 9 5 6 8 7 )
After sort_heap with greater<int>: ( 9 8 7 6 5 4 3 2 1 )

stable_partition

Mengklasifikasikan elemen dalam rentang menjadi dua set yang terputus-putus, dengan elemen yang memenuhi predikat unary yang mendahului yang gagal memenuhinya, mempertahankan urutan relatif elemen yang setara.

template<class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator stable_partition(
    BidirectionalIterator first,
    BidirectionalIterator last,
    UnaryPredicate pred );

template<class ExecutionPolicy, class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator stable_partition(
    ExecutionPolicy&& exec,
    BidirectionalIterator first,
    BidirectionalIterator last,
    UnaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator dua arah yang membahas posisi elemen pertama dalam rentang yang akan dipartisi.

last
Iterator dua arah yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dipartisi.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang harus dipenuhi jika elemen akan diklasifikasikan. Predikat unary mengambil satu argumen dan mengembalikan true jika puas, atau false jika tidak terpenuhi.

Nilai hasil

Iterator dua arah yang membahas posisi elemen pertama dalam rentang untuk tidak memenuhi kondisi predikat.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Elemen a dan b setara, tetapi belum tentu sama, jika keduanya pred( a, b ) salah dan pred( b, a ) salah, di mana pred adalah predikat yang ditentukan parameter. stable_partition Algoritma stabil dan menjamin bahwa pengurutan relatif elemen yang setara akan dipertahankan. Algoritma partition tidak selalu mempertahankan urutan asli ini.

Contoh

// 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;
}

Vector v1 is ( 4 10 5 5 5 5 5 1 6 9 3 7 8 2 0 5 ).
The partitioned set of elements in v1 is:
 ( 10 6 9 7 8 4 5 5 5 5 5 1 3 2 0 5 ).
The first element in v1 to fail to satisfy the
 predicate greater5 is: 4.

stable_sort

Mengatur elemen dalam rentang tertentu ke dalam urutan yang tidak menurun atau sesuai dengan kriteria pemesanan yang ditentukan oleh predikat biner. Ini mempertahankan urutan relatif dari elemen yang setara.

template<class BidirectionalIterator>
void stable_sort(
    BidirectionalIterator first,
    BidirectionalIterator last );

template<class BidirectionalIterator, class Compare>
void stable_sort(
    BidirectionalIterator first,
    BidirectionalIterator last,
    Compare pred );

template<class ExecutionPolicy, class RandomAccessIterator>
void stable_sort(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void stable_sort(
    ExecutionPolicy&& exec,
    RandomAccessIterator first,
    RandomAccessIterator last,
    Compare pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator dua arah yang membahas posisi elemen pertama dalam rentang yang akan diurutkan.

last
Iterator dua arah yang membahas posisi satu melewati elemen akhir dalam rentang yang akan diurutkan.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kriteria perbandingan yang harus dipenuhi oleh elemen berturut-turut dalam urutan. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Elemen setara, tetapi belum tentu sama, jika tidak kurang dari yang lain. sort Algoritma stabil dan menjamin bahwa pengurutan relatif elemen yang setara akan dipertahankan.

Kompleksitas stable_sort run-time tergantung pada jumlah memori yang tersedia, tetapi kasus terbaik (diberikan memori yang cukup) adalah O(N log N) dan kasus terburuk adalah O(N (log N)^2), di mana = last - first. Biasanya, sort algoritma lebih cepat daripada stable_sort.

Contoh

// 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 )

swap

Penimpaan pertama bertukar nilai dari dua objek. Penimpaan kedua bertukar nilai antara dua array objek.

template<class Type>
void swap(
    Type& left,
    Type& right);
template<class Type, size_t N>
void swap(
    Type (& left)[N],
    Type (& right)[N]);

Parameter

left
Untuk penimpaan pertama, objek pertama yang bertukar kontennya. Untuk penimpaan kedua, array objek pertama yang bertukar kontennya.

right
Untuk penimpaan pertama, objek kedua agar kontennya ditukar. Untuk penimpaan kedua, array kedua objek agar kontennya dipertukarkan.

Keterangan

Kelebihan beban pertama dirancang untuk beroperasi pada objek individual. Kelebihan beban kedua menukar konten objek di antara dua array.

Contoh

// 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

Menukar elemen dari satu rentang dengan elemen lain, rentang berukuran sama.

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges(
   ForwardIterator1 first1,
   ForwardIterator1 last1,
   ForwardIterator2 first2 );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator penerusan yang menunjuk ke posisi pertama rentang pertama yang elemennya akan ditukar.

last1
Iterator maju menunjuk ke satu melewati posisi akhir dari rentang pertama yang elemennya akan ditukar.

first2
Iterator penerusan yang menunjuk ke posisi pertama rentang kedua yang elemennya akan ditukar.

Nilai hasil

Iterator maju yang menunjuk ke satu melewati posisi akhir rentang kedua yang elemennya akan ditukar.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi. Rentang kedua harus sebesar rentang pertama.

Kompleksitasnya linier dengan pertukaran first1 - terakhir yang dilakukan. Jika elemen dari kontainer dengan jenis yang sama sedang ditukar, mereka swap fungsi anggota dari kontainer tersebut harus digunakan, karena fungsi anggota biasanya memiliki kompleksitas konstan.

Contoh

// 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 ).

transform

Menerapkan objek fungsi tertentu ke setiap elemen dalam rentang sumber atau ke sepasang elemen dari dua rentang sumber. Kemudian, ia menyalin nilai pengembalian objek fungsi ke dalam rentang tujuan.

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,
    InputIterator1 last1,
    InputIterator2 first2,
    OutputIterator result,
    BinaryFunction func );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class UnaryOperation>
ForwardIterator2 transform(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    UnaryOperation op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class ForwardIterator, class BinaryOperation>
ForwardIterator transform(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    ForwardIterator result,
    BinaryOperation binary_op);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first1
Iterator input yang membahas posisi elemen pertama dalam rentang sumber pertama yang akan dioperasikan.

last1
Iterator input yang mengatasi posisi satu melewati elemen akhir dalam rentang sumber pertama yang akan dioperasikan.

first2
Iterator input yang membahas posisi elemen pertama dalam rentang sumber kedua yang akan dioperasikan.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan.

func
Objek fungsi unary yang ditentukan pengguna yang digunakan dalam versi pertama algoritma untuk diterapkan ke setiap elemen dalam rentang sumber pertama atau objek fungsi biner yang ditentukan pengguna (UD) yang digunakan dalam versi kedua algoritma yang diterapkan secara berpasangan, dalam urutan maju, ke dua rentang sumber.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen akhir dalam rentang tujuan yang menerima elemen output yang diubah oleh objek fungsi.

Keterangan

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam setiap urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi. Rentang tujuan harus cukup besar untuk berisi rentang sumber yang diubah.

Jika hasil diatur sama dengan first1 dalam versi pertama algoritma, maka rentang sumber dan tujuan akan sama dan urutannya akan dimodifikasi di tempat. result Tetapi mungkin tidak mengatasi posisi dalam rentang [first1 + 1, last1).

Kompleksitasnya linier. Ini membuat perbandingan paling banyak (last1 - first1).

Contoh

// 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& value ) : Factor ( value ) { }

    // 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 ).

unique

Menghapus elemen duplikat yang bersebelahan dalam rentang tertentu.

template<class ForwardIterator>
ForwardIterator unique(
    ForwardIterator first,
    ForwardIterator last);

template<class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(
    ForwardIterator first,
    ForwardIterator last,
    BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator unique(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    BinaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang membahas posisi elemen pertama dalam rentang yang akan dipindai untuk penghapusan duplikat.

last
Iterator maju yang membahas posisi satu melewati elemen akhir dalam rentang yang akan dipindai untuk penghapusan duplikat.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator penerusan ke akhir baru urutan yang dimodifikasi yang tidak berisi duplikat berturut-turut, mengatasi posisi satu melewati elemen terakhir yang tidak dihapus.

Keterangan

Kedua bentuk algoritma menghapus duplikat kedua dari sepasang berturut-turut dari elemen yang sama.

Operasi algoritma stabil sehingga urutan relatif elemen yang tidak dihapus tidak diubah.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi. Jumlah elemen dalam urutan tidak diubah oleh algoritma unique dan elemen di luar akhir urutan yang dimodifikasi dapat didereferensikan tetapi tidak ditentukan.

Kompleksitasnya linier, membutuhkan (last - first) - 1 perbandingan.

List menyediakan fungsi anggota yang lebih efisien "unik", yang mungkin berkinerja lebih baik.

Algoritma ini tidak dapat digunakan pada kontainer asosiatif.

Contoh

// 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 greater<int> 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 greater<int> from vector v1 gives ( 5 7 ).

unique_copy

Menyalin elemen dari rentang sumber ke dalam rentang tujuan kecuali untuk elemen duplikat yang berada di samping satu sama lain.

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 pred );

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 unique_copy(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryPredicate>
ForwardIterator2 unique_copy(ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryPredicate pred);

Parameter

exec
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang membahas posisi elemen pertama dalam rentang sumber yang akan disalin.

last
Iterator penerusan yang membahas posisi satu melewati elemen akhir dalam rentang sumber yang akan disalin.

result
Iterator output yang membahas posisi elemen pertama dalam rentang tujuan yang menerima salinan dengan duplikat berturut-turut dihapus.

pred
Objek fungsi predikat yang ditentukan pengguna yang menentukan kondisi yang akan dipenuhi jika dua elemen harus diambil setara. Predikat biner mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator output yang membahas posisi satu melewati elemen akhir dalam rentang tujuan yang menerima salinan dengan duplikat berturut-turut dihapus.

Keterangan

Kedua bentuk algoritma menghapus duplikat kedua dari sepasang berturut-turut dari elemen yang sama.

Operasi algoritma stabil sehingga urutan relatif elemen yang tidak dihapus tidak diubah.

Rentang yang dirujuk harus valid; semua pointer harus dapat didereferensikan dan dalam urutan posisi terakhir dapat dijangkau dari yang pertama dengan inkrementasi.

Kompleksitasnya linier, membutuhkan (last - first) perbandingan.

Contoh

// 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;
}

Vector v1 is
 ( 5 -5 5 -5 4 4 4 7 10 10 10 10 10 10 ).
Copying the first half of the vector to the second half
 while removing adjacent duplicates gives
 ( 5 -5 5 -5 4 4 4 7 5 -5 5 -5 4 7 ).
Copying the first half of the vector to the second half
  removing adjacent duplicates under mod_equals gives
 ( 5 -5 5 -5 4 4 4 7 5 -5 5 -5 4 7 5 4 7 5 4 7 ).

upper_bound

Menemukan posisi elemen pertama dalam rentang berurutan yang memiliki nilai yang lebih besar dari nilai yang ditentukan. Predikat biner menentukan kriteria pemesanan.

template<class ForwardIterator, class Type>
ForwardIterator upper_bound(
    ForwardIterator first,
    ForwardIterator last,
    const Type& value);

template<class ForwardIterator, class Type, class Compare>
ForwardIterator upper_bound(
    ForwardIterator first,
    ForwardIterator last,
    const Type& value,
    Compare pred);

Parameter

first
Posisi elemen pertama dalam rentang yang akan dicari.

last
Posisi satu melewati elemen akhir dalam rentang yang akan dicari.

value
Nilai dalam rentang yang diurutkan yang perlu dilampaui oleh nilai elemen yang ditangani oleh iterator yang dikembalikan.

pred
Objek fungsi predikat perbandingan yang ditentukan pengguna yang menentukan pengertian di mana satu elemen kurang dari yang lain. Predikat perbandingan mengambil dua argumen dan kembali true ketika puas dan false ketika tidak puas.

Nilai hasil

Iterator penerusan ke posisi elemen pertama yang memiliki nilai lebih besar dari nilai yang ditentukan.

Keterangan

Rentang sumber yang diurutkan yang direferensikan harus valid; semua iterator harus dapat didereferensikan dan dalam urutan posisi terakhir harus dapat dijangkau dari yang pertama dengan inkrementasi.

Rentang yang diurutkan adalah prasyarat penggunaan upper_bound dan di mana kriteria pengurutan sama dengan yang ditentukan oleh predikat perbandingan.

Rentang tidak dimodifikasi oleh upper_bound.

Jenis nilai iterator penerusan harus kurang dari sebanding untuk diurutkan. Artinya, mengingat dua elemen, Anda dapat menentukan salah satunya kurang dari yang lain, atau bahwa elemen tersebut setara. (Di sini, setara berarti bahwa tidak kurang dari yang lain.) Perbandingan ini menghasilkan pengurutan antara elemen yang tidak setara.

Kompleksitas algoritma adalah logaritma untuk iterator akses acak dan linear jika tidak, dengan jumlah langkah yang proporsional dengan (last - first).

Contoh

// 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;
}

Starting vector v1 = ( -1 0 1 2 3 4 -3 -2 -1 0 ).
Original vector v1 with range sorted by the
 binary predicate less than is v1 = ( -3 -2 -1 -1 0 0 1 2 3 4 ).
Original vector v2 with range sorted by the
 binary predicate greater is v2 = ( 4 3 2 1 0 0 -1 -1 -2 -3 ).
Original vector v3 with range sorted by the
 binary predicate mod_lesser is v3 = ( 0 0 -1 -1 1 -2 2 -3 3 4 ).
The upper_bound in v1 for the element with a value of 3 is: 4.
The upper_bound in v2 for the element with a value of 3 is: 2.
The upper_bound in v3 for the element with a value of 3 is: 4.