<algorithm> işlevleri

adjacent_find

Eşit ya da belirli bir koşulu karşılayan iki bitişik öğeyi arar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Aranacak aralıktaki ilk öğenin konumunda ileri doğru yineleyici.

last
Aranacak aralıktaki son öğeyi geçen konumda ileriye doğru yineleyici.

pred
Aranmakta olan aralıktaki bitişik öğelerin değerleri tarafından karşılanması koşulu veren ikili koşul.

Dönüş değeri

Birbirine eşit (ilk sürümde) veya böyle bir öğe çifti bulunursa ikili koşul (ikinci sürümde) tarafından verilen koşulu karşılayan bitişik öğelerin ilkine iletin. Aksi takdirde, işaret eden last bir yineleyici döndürülür.

Açıklamalar

Algoritma adjacent_find , değişken olmayan bir dizi algoritmasıdır. Aranacak aralık geçerli olmalıdır. Tüm işaretçiler başvurulamamalıdır ve son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır. Algoritmanın zaman karmaşıklığı, aralıktaki öğelerin sayısında doğrusaldır.

operator== Öğeler arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Örnek

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

Belirtilen aralıktaki her öğede bir koşul olduğunda döndürür true .

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bir koşulu denetlemeye nereden başlayacağını gösteren bir giriş yineleyicisi. Yineleyici, bir öğe aralığının nerede başladığını işaretler.

last
Bir koşulu denetlemek için öğe aralığının sonunu gösteren bir giriş yineleyicisi.

pred
Test etmek için bir koşul. pred , denetlenen bir öğe tarafından karşılanacak koşulu tanımlayan kullanıcı tanımlı bir tekli koşul işlev nesnesidir. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Belirtilen aralıktaki her öğede koşul algılanırsa veya aralık boşsa ve false değilse döndürürtrue.

Açıklamalar

Şablon işlevi yalnızca aralığındaki [0, last - first)her N biri için koşulu pred(*(first + N)) ise truedöndürürtrue.

Örnek

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

Belirtilen öğe aralığında bir koşul en az bir kez mevcut olduğunda döndürür true .

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bir koşul için öğe aralığını denetlemeye nereden başlayacağını gösteren giriş yineleyicisi.

last
Bir koşulu denetlemek için öğe aralığının sonunu gösteren bir giriş yineleyicisi.

pred
Test etmek için bir koşul. Bu test, kullanıcı tanımlı bir koşul işlev nesnesi tarafından sağlanır. koşul, test edilen öğe tarafından karşılanacak koşulu tanımlar. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Koşul hiçbir zaman algılanmadıysa belirtilen false aralıkta en az bir kez algılanırsa döndürürtrue.

Açıklamalar

Şablon işlevi true yalnızca aralıktaki bazıları N için

[0, last - first), koşul pred(*(first + N)) doğrudur.

Örnek

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

Sıralanmış bir aralıkta belirtilen değere eşit olan veya ikili koşul tarafından belirtilen bir anlamda buna eşdeğer bir öğe olup olmadığını sınar.

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

Parametreler

first
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

value
Öğesinin değeriyle eşleşmesi gereken veya koşulu ikili koşul tarafından belirtilen öğe değeriyle karşılaması gereken değer.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

true belirtilen değere eşit veya eşdeğer aralıkta bir öğe bulunursa; aksi takdirde , false.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralığı geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Sıralanmış aralığın her biri binary_search algoritmanın uygulanması için bir önkoşul olarak, birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılmak üzere aynı sıralamaya göre düzenlenmelidir.

Kaynak aralıklar tarafından binary_searchdeğiştirilmez.

İleriye doğru yineleyicilerin değer türlerinin sıralanabilmesi için daha az karşılaştırılabilir olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan.

Algoritmanın karmaşıklığı, rastgele erişim yineleyicileri için logaritmiktir ve aksi takdirde doğrusaldır ve adım sayısı (last-first) ile orantılıdır.

Örnek

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

Bir değeri üst ve alt sınırla karşılaştırır ve sınırlar arasındaysa değere bir başvuru veya değer sırasıyla bunların üstünde veya altındaysa üst veya alt sınır başvurusu döndürür.

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

Parametreler

value
ve lowerile karşılaştıracak upper değer.

lower
Sıkıştırmak value için değerlerin alt sınırı.

upper
Sıkıştırmak value için değerlerin üst sınırı.

pred
veya upperile karşılaştırmak valuelower için kullanılan bir koşul. Karşılaştırma koşulu iki bağımsız değişken alır ve birinci bir anlamda ikinciden küçükse döndürür true ve aksi takdirde döndürür false.

Dönüş değeri

if için bir başvuru lower veya if value < loweriçin bir başvuru upperupper < valuedöndürür. Aksi takdirde, öğesine valuebir başvuru döndürür.

Açıklamalar

değerinden küçükse upperlowerdavranış tanımlanmamıştır.

copy

Bir kaynak aralığındaki öğe değerlerini bir hedef aralığına atayarak, öğelerin kaynak sırası boyunca yineler ve bunları yeni konumlarına ileri yönde atar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Kaynak aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Kaynak aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

destBeg
Hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

Dönüş değeri

Hedef aralıktaki son öğeden önceki konumu, yani yineleyici adreslerini result + (last - first ) adresleyen bir çıkış yineleyicisi.

Açıklamalar

Kaynak aralığının geçerli olması gerekir ve hedefte, kopyalanmakta olan tüm öğeleri tutmak için yeterli alan olmalıdır.

Algoritma, kaynak öğeleri ilk öğeden başlayarak sırayla kopyaladığı için, kaynak aralığın konumu hedef aralıkta yer almadığı takdirde last hedef aralık kaynak aralıkla çakışabilir. copy kaynak ve hedef aralıklar arasında çakışma olmadığı sürece öğeleri sola kaydırmak için kullanılabilir, ancak sağa kaydırılamaz. Herhangi bir sayıda konumu sağa kaydırmak için algoritmayı copy_backward kullanın.

Algoritma copy yalnızca yineleyicilerin işaret ettiği değerleri değiştirir ve hedef aralıktaki öğelere yeni değerler atar. Yeni öğeler oluşturmak için kullanılamaz ve doğrudan boş bir kapsayıcıya öğe ekleyemez.

Örnek

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

Bir kaynak aralığındaki öğe değerlerini bir hedef aralığına atayarak, öğelerin kaynak sırası boyunca yineler ve bunları yeni konumlarına geri yönde atar.

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

Parametreler

first
Kaynak aralıktaki ilk öğenin konumunu belirleyen çift yönlü yineleyici.

last
Kaynak aralıkta son öğeden bir önceki öğenin konumunu belirleyen çift yönlü yineleyici.

destEnd
Hedef aralıkta son öğeden bir önceki öğenin konumunu belirleyen çift yönlü yineleyici.

Dönüş değeri

Hedef aralıktaki son öğeyi (yineleyici adresi) geçen konumu ele alan bir çıkış yineleyicisi destEnd - (last - first).

Açıklamalar

Kaynak aralığının geçerli olması gerekir ve hedefte, kopyalanmakta olan tüm öğeleri tutmak için yeterli alan olmalıdır.

Algoritma, copy_backward algoritmadan copy daha sıkı gereksinimler uygular. Hem giriş hem de çıkış yineleyicileri çift yönlü olmalıdır.

copy_backward ve move_backward algoritmaları, çıkış aralığını hedef aralığın sonuna işaret eden bir yineleyiciyle belirleyen tek C++ Standart Kitaplık algoritmalarıdır.

Algoritma, kaynak öğeleri son öğeden başlayarak sırayla kopyaladığı için, kaynak aralığın konumu hedef aralıkta yer almadığı takdirde first hedef aralık kaynak aralıkla çakışabilir. copy_backward kaynak ve hedef aralıklar arasında çakışma olmadığı sürece öğeleri sağa kaydırmak için kullanılabilir, ancak sola kaydırılamaz. Herhangi bir sayıda konumu sola kaydırmak için algoritmayı copy kullanın.

Algoritma copy_backward yalnızca yineleyicilerin işaret ettiği değerleri değiştirir ve hedef aralıktaki öğelere yeni değerler atar. Yeni öğeler oluşturmak için kullanılamaz ve doğrudan boş bir kapsayıcıya öğe ekleyemez.

Örnek

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

Bir öğe aralığında, belirtilen koşul için olan true öğeleri kopyalar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Koşulu denetlemek için aralığın başlangıcını gösteren bir giriş yineleyicisi.

last
Aralığın sonunu gösteren bir giriş yineleyicisi.

dest
Kopyalanan öğelerin hedefini gösteren çıkış yineleyicisi.

pred
Aralıktaki her öğenin sınandığı koşul. Bu koşul, kullanıcı tanımlı koşul işlev nesnesi tarafından sağlanır. Birli koşul bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Koşulu yerine getiren dest her öğe için bir kez artırılan bir çıkış yineleyicisi. Başka bir deyişle, dönüş değeri eksi dest kopyalanan öğelerin sayısına eşittir.

Açıklamalar

Şablon işlevi tarafından değerlendirilir

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

aralıktaki her N biri için bir kez, en düşük değerle başlama değerlerini N kesinlikle artırmak [0, last - first)için. Depolama bölgelerini belirlerseniz ve first belirlersenizdest, dest aralığında [ first, last )olmamalıdır.

Örnek

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

Belirtilen sayıda öğeyi kopyalar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin nereden kopyalandığını gösteren bir giriş yineleyicisi.

count
Kopyalanacak öğe sayısını belirten imzalı veya imzasız tamsayı türü.

dest
Öğelerin nereye kopyalandığını gösteren bir çıkış yineleyicisi.

Dönüş değeri

Öğelerin kopyalandığı bir çıkış yineleyicisi döndürür. Parametrenin döndürülen değeriyle dest aynıdır.

Açıklamalar

Şablon işlevi, aralıktaki [0, count)her N biri için bir kez değerlendirir *(dest + N) = *(first + N)) ve en düşük değerle başlama değerlerini N kesinlikle artırır. Ardından döndürür dest + N. Depolama bölgelerini belirlerseniz ve first belirlersenizdest, dest aralığında [first, last)olmamalıdır.

Örnek

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

Değerleri belirtilen bir değerle eşleşen bir aralıktaki öğelerin sayısını döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Geçirilecek aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Geçirilecek aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

value
Sayılacak öğelerin değeri.

Dönüş değeri

değeri olan [, last) aralığındaki öğe sayısını sayan öğesinin valuefark türüInputIterator.first

Açıklamalar

Bir operator== öğe ile belirtilen değer arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi oluşturmalıdır.

Bu algoritma, şablon işleviyle count_ifherhangi bir koşula uyan öğeleri saymak için genelleştirilir.

Örnek

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

Değerleri belirtilen koşulu karşılayan bir aralıktaki öğe sayısını döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Aranacak aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Aranacak aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

pred
Bir öğe sayılacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Koşul tarafından belirtilen koşulu karşılayan öğe sayısı.

Açıklamalar

Bu şablon işlevi, algoritmanın countgenelleştirilmesidir ve "belirli bir değere eşittir" koşulunu herhangi bir koşulla değiştirir.

Örnek

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

İkili koşul tarafından belirtilen bir anlamda eşitlik veya denklik için öğeye göre iki aralık öğesini karşılaştırır.

Farklı kapsayıcı türlerindeki öğeleri karşılaştırırken (örneğin vector ve list) veya farklı öğe türlerini karşılaştırırken veya kapsayıcıların alt aralıklarını karşılaştırmanız gerektiğinde kullanınstd::equal. Aksi takdirde, aynı kapsayıcı türündeki aynı türdeki öğeleri karşılaştırırken, her kapsayıcı için sağlanan üye operator== olmayan öğeleri kullanın.

İkili aralık aşırı yüklemelerini C++14 kodunda kullanın çünkü ikinci aralık için yalnızca tek bir yineleyici alan aşırı yüklemeler, ikinci aralık ilk aralıktan uzunsa farkları algılamaz. Bu aşırı yüklemeler, ikinci aralık ilk aralıktan daha kısaysa tanımsız davranışa neden olur.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Test edilecek ilk aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Test edilecek ilk aralıktaki son öğeyi geçmiş konumu ele alan bir giriş yineleyicisi.

first2
Test edilecek ikinci aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Test edilecek ikinci aralıktaki son öğeden birinin konumunu ele alan bir giriş yineleyicisi.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

true eğer ve yalnızca öğeye göre karşılaştırıldığında aralıklar ikili koşul altında aynı veya eşdeğerse; aksi takdirde , false.

Açıklamalar

Aranacak aralık geçerli olmalıdır; tüm yineleyicilerin başvurulmaması gerekir ve son konuma ilk konumdan artımlı olarak ulaşılabilir.

İki aralık eşit uzunluktaysa, algoritmanın zaman karmaşıklığı aralıktaki öğelerin sayısında doğrusaldır. Aksi takdirde işlev hemen döndürür false.

İşlenenler arasında simetrik, esnek ve geçişli bir denklik ilişkisi uygulamak için ya da operator== kullanıcı tanımlı koşula ihtiyacınız yoktur.

Örnek

#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

Sıralı aralık verildiğinde, tüm öğelerin belirli bir değere eşdeğer olduğu alt aralığı bulur.

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

Parametreler

first
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

value
Sıralı aralıkta aranmakta olan değer.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Aranan aralığın içinde yer alan ve tüm öğelerin kullanılan pred ikili koşul (veya varsayılan, küçüktür) tarafından tanımlanan anlamda eşdeğer value olduğu bir alt aralık belirten bir çift ileriye doğru yineleyici.

Aralıktaki hiçbir öğe ile valueeşdeğer değilse, döndürülen çiftteki ileriye doğru yineleyiciler eşittir ve aralığın sırasını bozmadan eklenebileceği noktayı value belirtin.

Açıklamalar

Algoritma tarafından döndürülen çiftin ilk yineleyicisi olur lower_boundve ikinci yineleyici ise olur upper_bound.

Aralık, için sağlanan equal_rangekoşula göre sıralanmalıdır. Örneğin, büyüktür koşulunu kullanacaksanız, aralık azalan düzende sıralanmalıdır.

tarafından döndürülen equal_range yineleyici çifti tarafından tanımlanan büyük olasılıkla boş alt dizideki öğeler, kullanılan koşul tarafından tanımlanan anlamdaki değereeşdeğer olacaktır.

Algoritmanın karmaşıklığı, rastgele erişim yineleyicileri için logaritmiktir ve aksi takdirde doğrusaldır ve adım sayısı (last - first) ile orantılıdır.

Örnek

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

Aynı yeni değeri belirtilen bir aralıktaki her öğeye atar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Geçirilecek aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Geçirilecek aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

value
[first, last) aralığındaki öğelere atanacak değer.

Açıklamalar

Hedef aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve son konuma ilk konumdan artımlı olarak ulaşılabilir. Karmaşıklık, aralığın boyutuyla doğrusaldır.

Örnek

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

Belirli bir öğeden başlayarak bir aralıktaki belirli sayıda öğeye yeni bir değer atar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
değeri valueatanacak aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

count
Değerin atanacağı öğe sayısını belirten imzalı veya imzasız tamsayı türü.

value
[first, first + count) aralığındaki öğelere atanacak değer.

Dönüş değeri

Sıfır ise count> son öğeyi izleyen öğeye bir yineleyici, aksi takdirde ilk öğe.

Açıklamalar

Hedef aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve son konuma ilk konumdan artımlı olarak ulaşılabilir. Karmaşıklık, aralığın boyutuyla doğrusaldır.

Örnek

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

Bir öğenin belirli bir değere sahip olan aralıktaki ilk geçtiği konumu bulur.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Belirtilen değer için aranacak aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Belirtilen değer için aranacak aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

value
Aranacak değer.

Dönüş değeri

Aranan aralıkta belirtilen değerin ilk oluşumunu ele alan bir giriş yineleyicisi. Eşdeğer değere sahip bir öğe bulunmazsa döndürür last.

Açıklamalar

Bir operator== öğe ile belirtilen değer arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi oluşturmalıdır.

kullanan find()bir kod örneği için bkz find_if. .

find_end

Belirli bir diziye özdeş veya bir ikili koşula göre belirtildiği şekilde denk olan son dizi için bir aralık arar.

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

Parametreler

first1
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last1
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

first2
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last2
Aranacak aralıktaki son öğeden bir önceki konumu ele alan ileriye doğru yineleyici.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Belirtilen [first2, last2) dizisiyle eşleşen [first1, last1) içindeki son alt sorgunun ilk öğesinin konumunu ele alan ileriye doğru yineleyici.

Açıklamalar

Bir operator== öğe ile belirtilen değer arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi oluşturmalıdır.

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir.

Örnek

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

Bir hedef aralıktaki çeşitli değerlerden herhangi birinin ilk oluşumunu arar. Veya, bir ikili koşul tarafından belirtilen bir öğe kümesiyle belirtilen bir anlamda eşdeğer olan birkaç öğeden herhangi birinin ilk oluşumunu arar.

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

Parametreler

first1
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last1
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

first2
Eşleştirilecek aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last2
Eşleştirilecek aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Belirtilen diziyle eşleşen veya bir ikili koşul tarafından belirtilen bir anlamda eşdeğer olan ilk alt dizinin ilk öğesinin konumunu ele alan ileriye doğru yineleyici.

Açıklamalar

Bir operator== öğe ile belirtilen değer arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi oluşturmalıdır.

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir.

Örnek

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

Bir öğenin belirli bir koşulu karşıladığı aralıktaki ilk geçtiği konumu bulur.

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

Parametreler

first
Aranacak aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Aranacak aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

pred
Aranan öğe tarafından karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi veya lambda ifadesi . Birli koşul tek bir bağımsız değişken alır ve memnunsanız veya false memnun değilse döndürürtrue. İmzası pred etkin bir şekilde olmalıdır bool pred(const T& arg);; burada T başvurulduğunda örtük olarak dönüştürülebilen bir türdür InputIterator . const anahtar sözcüğü yalnızca işlev nesnesinin veya lambdanın bağımsız değişkeni değiştirmemesi gerektiğini göstermek için gösterilir.

Dönüş değeri

Koşul tarafından belirtilen koşulu karşılayan aralıktaki ilk öğeye başvuran bir giriş yineleyicisi (koşul ile truesonuç verir). Koşulu karşılayan bir öğe bulunamazsa, döndürür last.

Açıklamalar

Bu şablon işlevi, algoritmanın findgenelleştirilmesidir ve "belirli bir değere eşittir" koşulunu herhangi bir koşulla değiştirir. Mantıksal karşıtlık için (koşulu karşılamayan ilk öğeyi bulun), bkz find_if_not. .

Örnek

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

Belirtilen aralıktaki bir koşulu karşılamayan ilk öğeyi döndürür.

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

Parametreler

first
Aranacak aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Aranacak aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

pred
Aranan öğe tarafından karşılanmayacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi veya lambda ifadesi . Birli koşul tek bir bağımsız değişken alır ve memnunsanız veya false memnun değilse döndürürtrue. İmzası pred etkin bir şekilde olmalıdır bool pred(const T& arg);; burada T başvurulduğunda örtük olarak dönüştürülebilen bir türdür InputIterator . const anahtar sözcüğü yalnızca işlev nesnesinin veya lambdanın bağımsız değişkeni değiştirmemesi gerektiğini göstermek için gösterilir.

Dönüş değeri

Aralıktaki koşul tarafından belirtilen koşulu karşılamayan ilk öğeye başvuran bir giriş yineleyicisi (koşul ile sonuç verir false). Tüm öğeler koşulu karşılarsa (koşul her öğe için sonuçlanırsa true ), döndürür last.

Açıklamalar

Bu şablon işlevi, algoritmanın findgenelleştirilmesidir ve "belirli bir değere eşittir" koşulunu herhangi bir koşulla değiştirir. Mantıksal karşıtlık için (koşulu karşılayan ilk öğeyi bulun), bkz find_if. .

için uyarlanabilir bir kod örneği için find_if_not()bkz find_if. .

for_each

Bir aralıktaki ileriye doğru sıradaki her öğeye belirli bir işlev uygular ve işlev nesnesini döndürür.

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

Parametreler

first
Üzerinde çalışılması gereken aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Üzerinde çalışılan aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

func
Aralıktaki her öğeye uygulanan kullanıcı tanımlı işlev nesnesi.

Dönüş değeri

Aralıktaki tüm öğelere uygulandıktan sonra işlev nesnesinin bir kopyası.

Açıklamalar

Algoritma for_each esnektir ve bir aralıktaki her öğenin farklı, kullanıcı tarafından belirtilen yollarla değiştirilmesine olanak tanır. Şablon haline getirilmiş işlevler, farklı parametreler geçirilerek değiştirilmiş bir biçimde yeniden kullanılabilir. Kullanıcı tanımlı işlevler, aralıktaki tüm öğeler işlendikten sonra algoritmanın döndürebileceği bir iç durum içinde bilgi toplayabilir.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Karmaşıklık, en çok (last - first) karşılaştırma ile doğrusaldır.

Örnek

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

Belirli bir işlev nesnesini, belirli bir öğeden başlayarak bir aralıktaki belirtilen sayıda öğeye uygular.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Üzerinde çalışacak aralıktaki ilk öğenin konumundaki bir giriş yineleyicisi.

count
Üzerinde çalışacak öğe sayısı.

func
[first, first + count) aralığındaki her öğeye uygulanacak kullanıcı tanımlı işlev nesnesi.

Dönüş değeri

Sıfır olduğunda count> işlenen son öğeden sonra gelen öğeye bir yineleyici, aksi takdirde ilk öğe.

Açıklamalar

count negatif olmamalıdır ve en az count öğesinden firstbaşlayarak aralığında olmalıdır.

Örnek

Bu örnek bir işlev nesnesi sınıfı tanımlar. Üretim kodu genellikle daha az kodla aynı sonucu elde etmek için kullanır lambda .

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

Bir işlev nesnesi tarafından oluşturulan değerleri bir aralıktaki her öğeye atar.

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

Parametreler

first
Değerlerin atanacağı aralıktaki ilk öğenin konumunda ileriye doğru yineleyici.

last
Değerlerin atanacağı aralıktaki son öğeyi geçen konumda ileri doğru yineleyici.

gen
Aralıktaki öğelerin her birine atanacak değerleri oluşturmak için bağımsız değişkeni olmayan çağrılan bir işlev nesnesi.

Açıklamalar

İşlev nesnesi aralıktaki her öğe için çağrılır ve her çağrıldığında aynı değeri döndürmesi gerekmez. Örneğin, bir dosyadan okuyabilir veya yerel bir duruma başvurabilir ve bu durumu değiştirebilir. Oluşturucunun sonuç türü, aralık için ileriye doğru yineleyicinin değer türüne dönüştürülebilir olmalıdır.

Başvuruda bulunılan aralık geçerli olmalıdır. Tüm işaretçiler başvurulmamalıdır ve dizi içinde, son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Karmaşıklık doğrusaldır ve tam olarak last - first oluşturucuya çağrı yapılır.

Örnek

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

Bir işlev nesnesi tarafından oluşturulan değerleri bir aralıktaki belirtilen sayıda öğeye atar. Son atanan değerin bir önceki konumunu döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Değerlerin atanacağı aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

count
Oluşturucu işlevi tarafından bir değer atanacak öğe sayısını belirten imzalı veya imzasız tamsayı türü.

gen
Aralıktaki öğelerin her birine atanacak değerleri oluşturmak için kullanılan bağımsız değişkenler olmadan çağrılan bir işlev nesnesi.

Açıklamalar

İşlev nesnesi aralıktaki her öğe için çağrılır ve her çağrıldığında aynı değeri döndürmesi gerekmez. Örneğin, bir dosyadan okuyabilir veya yerel bir duruma başvurabilir ve bu durumu değiştirebilir. Oluşturucunun sonuç türü, aralık için ileriye doğru yineleyicilerin değer türüne dönüştürülebilir olmalıdır.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Karmaşıklık doğrusaldır ve oluşturucuya tam olarak count çağrı yapılması gerekir.

Örnek

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

Sıralanmış bir aralığın ikinci bir sıralanmış aralıkta kapsanan tüm öğeleri içerip içermediğini sınar, burada öğeler arasındaki sıralama veya denklik ölçütü bir ikili koşula göre belirlenebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
İkincinin tüm öğelerinin birincisinde bulunup bulunmadığını test etmek için iki sıralanmış kaynak aralığının ilkindeki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
İkincinin tüm öğelerinin birincisinde bulunup bulunmadığını test etmek üzere iki sıralanmış kaynak aralığının ilkindeki son öğeden önceki konumu ele alan bir giriş yineleyicisi.

first2
İkincinin tüm öğelerinin birincisinde bulunup bulunmadığını test etmek için, ardışık sıralanmış iki kaynak aralığının ikincisinde ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last2
İkincinin tüm öğelerinin birincisinde bulunup bulunmadığını test etmek üzere ardışık sıralanmış iki kaynak aralığının saniyedeki son öğesinin bir önceki konumunu ele alan bir giriş yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

true birinci sıralanmış aralık ikinci sıralanmış aralıktaki tüm öğeleri içeriyorsa; aksi takdirde , false.

Açıklamalar

Bu testi düşünmenin bir diğer yolu da ikinci kaynak aralığın ilk kaynak aralığın bir alt kümesi olup olmadığını belirlemesidir.

Başvuruda bulunılan sıralanmış kaynak aralıkları geçerli olmalıdır; tüm işaretçiler başvurulamamalıdır ve her dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir olmalıdır.

Algoritmanın includesuygulanması için önkoşul olarak, sıralanmış kaynak aralıklarının her biri algoritma tarafından birleştirilmiş aralıkları sıralamak için kullanılan sıralamayla aynı düzende düzenlenmelidir.

Kaynak aralıklar algoritması mergetarafından değiştirilmez.

Giriş yineleyicilerinin değer türlerinin sıralanması için karşılaştırılabilirden az olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan. Daha kesin olarak, algoritma, belirtilen ikili koşul altındaki ilk sıralanmış aralıktaki tüm öğelerin ikinci sıralanmış aralıktakilerle eşdeğer sıralamaya sahip olup olmadığını test eder.

Algoritmanın karmaşıklığı, olmayan kaynak aralıkları için en fazla 2 * ((last1 - first1) + (last2 - first2)) - 1 karşılaştırma ile doğrusaldır.

Örnek

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

Ardışık iki sıralanmış aralıktaki öğeleri tek bir sıralanmış aralıkta birleştirir, burada sıralama ölçütü bir ikili koşula göre belirtilebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Birleştirilecek ve tek bir aralıkta sıralanacak iki ardışık sıralanmış aralığın ilkindeki ilk öğenin konumunu ele alan çift yönlü yineleyici.

middle
Birleştirilecek ve tek bir aralıkta sıralanacak iki ardışık sıralanmış aralığın ikincisindeki ilk öğenin konumunu ele alan çift yönlü yineleyici.

last
Birleştirilecek ve tek bir aralıkta sıralanacak iki ardışık sıralanmış aralığın ikincisinde son öğeyi geçen konumu ele alan çift yönlü yineleyici.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçükse ve false değilse döndürülmelidirtrue.

Açıklamalar

Başvuruda bulunılan sıralanmış ardışık aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamamalıdır ve her dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir olmalıdır.

Sıralanmış ardışık aralıkların her biri inplace_merge , algoritmanın uygulanması için birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılacak aynı sıralamaya göre bir önkoşul olarak düzenlenmelidir. Her aralıktaki öğelerin göreli sırası korunduğu için işlem kararlıdır. Her iki kaynak aralıkta da eşdeğer öğeler olduğunda, öğe birleştirilmiş aralıktaki ikinciden önce gelen ilk aralıktır.

Algoritma geçici bir arabelleğe bellek ayırdıkça karmaşıklık kullanılabilir belleğe bağlıdır. Yeterli bellek varsa, en iyi durum karşılaştırmalarla (last - first) - 1 doğrusaldır; yardımcı bellek yoksa, en kötü durum N log(N), burada olur - Nlast = first.

Örnek

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

Belirtilen aralıktaki öğeler bir yığın oluşturup oluşturmadığını döndürür true .

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Yığını denetlemek için aralığın başlangıcını gösteren rastgele erişim yineleyicisi.

last
Aralığın sonunu gösteren rastgele erişim yineleyicisi.

pred
Öğeleri sıralamak için test edilmesi gereken bir koşul. Karşılaştırma koşulu iki bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Belirtilen aralıktaki öğeler bir yığın oluşturup oluşturmazlarsa döndürür truefalse .

Açıklamalar

İlk şablon işlevi döndürür is_heap_until(first , last) == last.

İkinci şablon işlevi,

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

is_heap_until

[ first, last) aralığındaki ilk öğede, yığın sıralama koşulunu karşılamayan veya end aralık bir yığın oluşturuyorsa konumlandırılan bir yineleyici döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bir yığını denetlemek için aralığın ilk öğesini belirten rastgele erişim yineleyicisi.

last
Yığın denetimi için aralığın sonunu belirten rastgele erişim yineleyicisi.

pred
Yığın tanımlayan katı zayıf sıralama koşulunu belirten ikili koşul. Varsayılan koşul belirtilmediğindedir std::less<>pred .

Dönüş değeri

Belirtilen aralık bir yığın oluşturuyorsa veya bir veya daha az öğe içeriyorsa döndürür last . Aksi takdirde, yığın koşulunu karşılamayan ilk öğe için bir yineleyici döndürür.

Açıklamalar

İlk şablon işlevi, içinde işlev nesnesi std::less<>tarafından sıralanmış bir yığın olan son yineleyiciyi [first, next)next[first, last) döndürür. Uzaklık last - first 2'den küçükse işlevi döndürür last.

İkinci şablon işlevi, yığın sıralama koşulu yerine std::less<> koşulunu pred kullanması dışında birinciyle aynı şekilde davranır.

is_partitioned

Belirli bir aralıktaki bir koşulu test true eden tüm öğelerin test eden falseöğelerden önce gelip gelmediğini döndürürtrue.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bir aralığın koşulu denetlemeye başladığı yeri gösteren giriş yineleyicisi.

last
Aralığın sonunu gösteren giriş yineleyicisi.

pred
Sınanacak koşul. Bu test, aranmakta olan öğe tarafından karşılanacak koşulu tanımlayan kullanıcı tanımlı bir koşul işlev nesnesi tarafından sağlanır. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

true Belirli bir aralıktaki bir koşulu test eden öğelerin tümü, öğesini test truefalseeden herhangi bir öğeden önce geldiğinde ve aksi takdirde döndürdüğünde döndürürfalse.

Açıklamalar

Şablon işlevi yalnızca içindeki tüm öğeler tarafından predbölümlenmişse, yani içinde true olan pred (X) tüm öğeler X[first, last) için olan falsepred (Y) tüm öğelerden Y önce gerçekleşirse döndürürtrue.[first, last)

is_permutation

Her iki aralık da öğelerin aynı sırada olup olmadığına bakılmaksızın aynı öğeleri içeriyorsa döndürür true . İkili aralık aşırı yüklemelerini C++14 kodunda kullanın çünkü ikinci aralık için yalnızca tek bir yineleyici alan aşırı yüklemeler, ikinci aralık ilk aralıktan uzunsa farkları algılamaz. Bu aşırı yüklemeler, ikinci aralık ilk aralıktan daha kısaysa tanımsız davranışa neden olur.

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

Parametreler

first1
Aralığın ilk öğesine başvuran ileriye doğru yineleyici.

last1
Aralığın son öğesini geçen bir öğeye başvuran ileriye doğru yineleyici.

first2
Karşılaştırma için kullanılan ikinci aralığın ilk öğesine başvuran ileriye doğru yineleyici.

last2
Karşılaştırma için kullanılan ikinci bir aralığın son öğesini geçmiş bir öğeye başvuran ileriye doğru yineleyici.

pred
Denkliği sınayan ve döndüren bir boolkoşul.

Dönüş değeri

true aralıkların karşılaştırıcı koşuluna göre aynı olacak şekilde yeniden düzenlenebileceği durumlarda; aksi takdirde , false.

Açıklamalar

is_permutation en kötü durumda ikinci derecede karmaşıklık gösterir.

İlk şablon işlevi, aralıkta tarafından [first1, last1)belirlenen aralıkta olduğu kadar çok first2 öğe olduğunu varsayar. İkinci aralıkta daha fazla öğe varsa bunlar yoksayılır; daha az varsa, tanımsız davranış oluşur. Üçüncü şablon işlevi (C++14 ve üzeri) bu varsayımda bulunmaz. Her ikisi de yalnızca tarafından belirlenen [first1, last1) aralıktaki her öğe X için veya ile başlayan [first2, last2)first2 aralıkta X == Y olduğu kadar çok öğe Y varsa döndürürtrue. Burada, operator== işlenenleri arasında çift tabanlı bir karşılaştırma gerçekleştirmelidir.

İkinci ve dördüncü şablon işlevleri, yerine ile Pred(X, Y)değiştirmeleri operator==(X, Y) dışında aynı şekilde davranır. Doğru davranabilmek için koşul simetrik, esnek ve geçişli olmalıdır.

Örnek

Aşağıdaki örnekte nasıl kullanılacağı gösterilmektedir 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

Belirtilen aralıktaki öğeler sıralı düzendeyse döndürür true .

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Denetlenecek aralığın nerede başladığını gösteren ileriye doğru yineleyici.

last
Aralığın sonunu gösteren ileriye doğru yineleyici.

pred
İki öğe arasındaki bir sırayı belirlemek için test edilmesi gereken koşul. Karşılaştırma koşulu iki bağımsız değişken alır ve veya falsedöndürürtrue. Bu koşul ile aynı görevi operator<gerçekleştirir.

Açıklamalar

İlk şablon işlevi döndürür is_sorted_until( first, last ) == last. İşlev, operator< sipariş karşılaştırmasını gerçekleştirir.

İkinci şablon işlevi döndürür is_sorted_until( first, last , pred ) == last. pred koşul işlevi, sipariş karşılaştırmasını gerçekleştirir.

is_sorted_until

ForwardIterator Belirtilen aralıktan sıralanmış durumda olan son öğeye ayarlanmış bir döndürür.

İkinci sürüm, verilen iki öğe sıralı düzende olduğunda ve false aksi halde döndüren true bir karşılaştırma işlevi nesnesi sağlamanıza olanak tanır.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Denetlenecek aralığın nerede başladığını gösteren ileriye doğru yineleyici.

last
Aralığın sonunu gösteren ileriye doğru yineleyici.

pred
İki öğe arasındaki bir sırayı belirlemek için test edilmesi gereken koşul. Karşılaştırma koşulu iki bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Sıralanmış düzende son öğeye ayarlanmış bir ForwardIterator küme döndürür. Sıralanan sıra, uygulamasından firstbaşlar.

Açıklamalar

İlk şablon işlevi, içindeki [first, last] son yineleyiciyi next döndürür, böylece [first, next) sıralı bir dizi tarafından operator<sıralanır. 2'den küçükse distance() işlevi döndürür last.

İkinci şablon işlevi ile değiştirilmesi operator<(X, Y)pred(X, Y)dışında aynı şekilde davranır.

iter_swap

Belirtilen yineleyicilerin bir çifti tarafından başvurulan iki değeri birbiriyle değiştirir.

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

Parametreler

left
Değeri değiştirilecek ileriye doğru yineleyicilerden biri.

right
değeri değiştirilecek ileriye doğru yineleyicilerin ikincisi.

Açıklamalar

swap geriye dönük uyumluluk için C++ Standard'da yer alan iter_swap tercihinde kullanılmalıdır. Fit1 ve Fit2 ileri yineleyici ise, iter_swap( Fit1, Fit2 )ile eşdeğerdirswap( *Fit1, *Fit2 ).

Giriş iletme yineleyicilerinin değer türleri aynı değere sahip olmalıdır.

Örnek

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

Daha küçük olanı belirlemek için iki diziyi öğe öğe karşılaştırır.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Karşılaştırılacak ilk aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Karşılaştırılacak ilk aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

first2
Karşılaştırılacak ikinci aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Karşılaştırılacak ikinci aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

true İlk aralık sözcük temelli olarak ikinci aralıktan küçükse; aksi takdirde false.

Açıklamalar

Sıralar arasındaki sözcüksal karşılaştırma, öğeye göre aşağıdakilere kadar öğeyi karşılaştırır:

• Karşılık gelen iki öğeyi eşit değil bulur ve bunların karşılaştırmasının sonucu, diziler arasındaki karşılaştırmanın sonucu olarak alınır.

• Eşitsizlik bulunmaz, ancak bir dizi diğerinden daha fazla öğeye sahiptir ve daha kısa dizi, uzun diziden daha az olarak kabul edilir.

• Eşitsizlik bulunamadı ve diziler aynı sayıda öğeye sahip olduğundan diziler eşit olur ve karşılaştırmanın sonucu olur false.

Örnek

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

Belirtilen değerden büyük veya eşdeğer bir değere sahip sıralı aralıktaki ilk öğenin konumunu bulur. Sıralama ölçütü bir ikili koşul tarafından belirtilebilir.

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

Parametreler

first
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

value
İlk konumu veya olası ilk konumu sıralı aralıkta aranmakta olan değer.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Belirtilen değerden büyük veya eşdeğer bir değere sahip, sıralı aralıktaki ilk öğenin konumunda ileri doğru yineleyici. Denklik bir ikili koşulla belirtilebilir.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralığı geçerli olmalıdır; tüm yineleyiciler başvurulamamalıdır ve dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir olmalıdır.

Sıralanmış aralık, kullanarak lower_bound ve sıralamanın ikili koşulda belirtilenle aynı olduğu bir önkoşuldur.

Aralığı algoritması lower_boundtarafından değiştirilmez.

İleriye doğru yineleyicilerin değer türlerinin sıralanabilmesi için daha az karşılaştırılabilir olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan.

Algoritmanın karmaşıklığı, rastgele erişim yineleyicileri için logaritmiktir ve aksi takdirde doğrusaldır ve adım sayısı (last - first) ile orantılıdır.

Örnek

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

Belirtilen bir aralıktaki öğeleri ilk öğenin en büyük olduğu ve onun için bir ikili koşula sahip bir sıralama ölçütünün belirtilebildiği bir yığına dönüştürür.

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

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

Parametreler

first
Yığına dönüştürülecek aralıktaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

last
Yığına dönüştürülecek aralıktaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

Yığınların iki özelliği vardır:

• İlk öğe her zaman en büyük öğedir.

• Öğeler logaritmik zamanda eklenebilir veya kaldırılabilir.

Yığınlar, öncelik kuyruklarını uygulamak için ideal bir yoldur ve C++ Standart Kitaplık kapsayıcı bağdaştırıcısı priority_queue Sınıfı'nın uygulanmasında kullanılır.

Karmaşıklık doğrusaldır ve karşılaştırmalar gerekir 3 * (last - first) .

Örnek

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

İki nesneyi karşılaştırır ve ikisinden büyük olanı döndürür, burada sıralama ölçütü ikili bir koşula göre belirtilebilir.

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

Parametreler

left
Karşılaştırılan iki nesneden ilki.

right
Karşılaştırılan iki nesnenin ikincisi.

pred
İki nesneyi karşılaştırmak için kullanılan ikili koşul.

inlist
Karşılaştırılacak nesneleri içeren başlatıcı listesi.

Dönüş değeri

İkisi de büyük değilse, iki nesnenin büyük olması; bu durumda, iki nesneden ilkini döndürür. belirtildiğinde initializer_list , listedeki nesnelerin en büyük değerini döndürür.

Açıklamalar

Algoritma max , nesnelerin parametre olarak geçirilmesinde olağan dışıdır. C++ Standart Kitaplığı algoritmalarının çoğu, konumu parametre olarak geçirilen yineleyiciler tarafından belirtilen bir dizi öğe üzerinde çalışır. Bir dizi öğe üzerinde çalışan bir işleve ihtiyacınız varsa, bunun yerine kullanın max_element . Visual Studio 2017, bir initializer_listkullanan aşırı yüklemeleri etkinleştirirconstexpr.

Örnek

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

Belirtilen bir aralıktaki en büyük öğenin geçtiği ilk yeri bulur, burada sıralama ölçütü bir ikili koşula göre belirtilebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
En büyük öğe için aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
En büyük öğe için aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçükse ve false değilse döndürülmelidirtrue.

Dönüş değeri

Aranan aralıktaki en büyük öğenin ilk oluşumunun konumunu ele alan ileriye doğru yineleyici.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Karmaşıklık doğrusaldır: (last - first) - 1 Olmayan bir aralık için karşılaştırmalar gerekir.

Örnek

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

İki sıralanmış kaynak aralığındaki tüm öğeleri tek bir sıralanmış hedef aralıkta birleştirir; burada sıralama ölçütü bir ikili koşula göre belirtilebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Birleştirilecek ve tek bir aralıkta sıralanacak iki sıralanmış kaynak aralığının ilkindeki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Birleştirilecek ve tek bir aralıkta sıralanacak iki sıralanmış kaynak aralığının ilkindeki son öğeden önceki konumu ele alan bir giriş yineleyicisi.

first2
Birleştirilecek ve tek bir aralıkta sıralanacak iki ardışık sıralanmış kaynak aralığının ikincisinde birinci öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Birleştirilecek ve tek bir aralıkta sıralanacak iki ardışık sıralanmış kaynak aralığının saniyesinde son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
İki kaynak aralığın tek bir sıralanmış aralıkta birleştirileceği hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçük olduğunda döndürülmelidir true ve false aksi takdirde.

Dönüş değeri

Sıralanmış hedef aralığındaki son öğeden önceki konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralıkları geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Hedef aralık, kaynak aralıklardan herhangi biriyle çakışmamalı ve hedef aralığı içerecek kadar büyük olmalıdır.

Sıralanmış kaynak aralıklarının her biri algoritmanın merge uygulanması için bir önkoşul olarak, birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılmak üzere aynı sıralamaya göre düzenlenmelidir.

Her aralıktaki öğelerin göreli sırası hedef aralıkta korunduğu için işlem kararlıdır. Kaynak aralıklar algoritması mergetarafından değiştirilmez.

Giriş yineleyicilerinin değer türlerinin sıralanması için karşılaştırılabilirden az olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan. Her iki kaynak aralıkta da eşdeğer öğeler olduğunda, ilk aralıktaki öğeler hedef aralıktaki ikinci kaynak aralığından önce gelen öğelerdir.

Algoritmanın karmaşıklığı, çoğu (last1 - first1) - (last2 - first2) - 1 karşılaştırmada doğrusaldır.

sınıfı, list iki liste öğelerini birleştirmek için bir üye işlevi merge sağlar.

Örnek

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

İki nesneyi karşılaştırır ve ikisinden küçük olanı döndürür, burada sıralama ölçütü ikili bir koşula göre belirtilebilir.

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

Parametreler

left
Karşılaştırılan iki nesneden ilki.

right
Karşılaştırılan iki nesnenin ikincisi.

pred
İki nesneyi karşılaştırmak için kullanılan ikili koşul.

inlist
Karşılaştırılacak initializer_list üyeleri içeren.

Dönüş değeri

İkisi de daha az değilse, iki nesneden daha küçüktür; bu durumda, iki nesneden ilkini döndürür. belirtildiğinde initializer_list , listedeki nesnelerin en azını döndürür.

Açıklamalar

Algoritma min , nesnelerin parametre olarak geçirilmesinde olağan dışıdır. C++ Standart Kitaplığı algoritmalarının çoğu, konumu parametre olarak geçirilen yineleyiciler tarafından belirtilen bir dizi öğe üzerinde çalışır. Bir öğe aralığı kullanan bir işleve ihtiyacınız varsa kullanın min_element. constexpr , Visual Studio 2017'de aşırı yüklemelerde etkinleştirildi initializer_list .

Örnek

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

Belirtilen bir aralıktaki en küçük öğenin geçtiği ilk yeri bulur, burada sıralama ölçütü bir ikili koşula göre belirtilebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
En küçük öğe için aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
En küçük öğe için aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçük olduğunda döndürülmelidir true ve false aksi takdirde.

Dönüş değeri

Aranan aralıktaki en küçük öğenin ilk oluşumunun konumunu ele alan ileriye doğru yineleyici.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Karmaşıklık doğrusaldır: (last - first) - 1 Olmayan bir aralık için karşılaştırmalar gerekir.

Örnek

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

ve tarafından min_elementmax_element gerçekleştirilen işi tek bir çağrıda gerçekleştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Aralığın başlangıcını gösteren ileriye doğru yineleyici.

last
Aralığın sonunu gösteren ileriye doğru yineleyici.

pred
Bir öğenin başka bir öğeden daha az olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve ilki ikinciden küçük olduğunda ve false aksi takdirde döndürülmelidirtrue.

Dönüş değeri

İadeler

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

Açıklamalar

İlk şablon işlevi döndürülüyor

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

İkinci şablon işlevi ile değiştirilmesi operator<(X, Y)pred(X, Y)dışında aynı şekilde davranır.

Dizi boş değilse, işlev en fazla 3 * (last - first - 1) / 2 karşılaştırma yapar.

minmax

İki giriş parametresini karşılaştırır ve daha küçükten büyüye doğru bir çift olarak döndürür.

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

Parametreler

left
Karşılaştırılan iki nesneden ilki.

right
Karşılaştırılan iki nesnenin ikincisi.

pred
İki nesneyi karşılaştırmak için kullanılan ikili koşul.

inlist
Karşılaştırılacak initializer_list üyeleri içeren.

Açıklamalar

İlk şablon işlevi değerinden leftküçükse right döndürürpair<const Type&, const Type&>( right, left ). Aksi takdirde döndürür pair<const Type&, const Type&>( left, right ).

İkinci üye işlevi, koşul ile predkarşılaştırıldığında ilk öğenin daha küçük, ikincisinin ise daha büyük olduğu bir çift döndürür.

Kalan şablon işlevleri, ve right parametrelerini ile inlistdeğiştirmeleri left dışında aynı şekilde davranır.

işlevi tam olarak bir karşılaştırma gerçekleştirir.

mismatch

öğeye göre iki aralık öğesini karşılaştırır ve bir farkın oluştuğu ilk konumu bulur.

İkili aralık aşırı yüklemelerini C++14 kodunda kullanın çünkü ikinci aralık için yalnızca tek bir yineleyici alan aşırı yüklemeler, ikinci aralık ilk aralıktan uzunsa farkları algılamaz. Bu aşırı yüklemeler, ikinci aralık ilk aralıktan daha kısaysa tanımsız davranışa neden olur.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Test edilecek ilk aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Test edilecek ilk aralıktaki son öğeyi geçmiş konumu ele alan bir giriş yineleyicisi.

first2
Test edilecek ikinci aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Test edilecek ikinci aralıktaki son öğeden birinin konumunu ele alan bir giriş yineleyicisi.

pred
Her aralıktaki geçerli öğeleri karşılaştıran ve bunların eşdeğer olup olmadığını belirleyen kullanıcı tanımlı koşul işlev nesnesi. Bu, memnun olduğunda ve false memnun olmadığında döndürürtrue.

Dönüş değeri

İki aralıktaki uyuşmazlıkların konumlarını ele alan bir çift yineleyici döndürür. İlk bileşen yineleyicisi ilk aralıktaki konumu gösterir. İkinci bileşen yineleyicisi ikinci aralıktaki konumu gösterir. Aralıklardaki öğeler arasında karşılaştırılan bir fark yoksa veya ikinci sürümdeki ikili koşul iki aralıktaki tüm öğe çiftleri tarafından karşılanıyorsa, ilk bileşen yineleyicisi ilk aralıktaki son öğeyi bir geçen konumu, ikinci bileşen yineleyicisi ise ikinci aralıkta test edilen son öğeyi geçen konumu gösterir.

Açıklamalar

İlk şablon işlevi, [ilk1, son1) tarafından belirlenen aralıkta olduğu kadar ilk2'de başlayan aralıkta da çok sayıda öğe olduğunu varsayar. İkinci aralıkta daha fazlası varsa bunlar yoksayılır; daha az varsa, tanımsız davranış sonuçlanır.

Aranacak aralık geçerli olmalıdır; tüm yineleyicilerin başvurulmaması gerekir ve son konuma ilk konumdan artımlı olarak ulaşılabilir.

Algoritmanın zaman karmaşıklığı, daha kısa aralıkta yer alan öğe sayısında doğrusaldır.

Kullanıcı tanımlı koşul, işlenenleri arasında simetrik, esnek ve geçişli bir denklik ilişkisi uygulamak için gerekli değildir.

Örnek

Aşağıdaki örnekte uyumsuzluğun nasıl kullanılacağı gösterilmektedir. C++03 aşırı yüklemesi yalnızca beklenmeyen bir sonucu nasıl oluşturabileceğini göstermek için gösterilir.

#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

Belirtilen aralıkla ilişkili öğeleri taşı.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Taşınacak öğe aralığının nereden başlatıldığını gösteren bir giriş yineleyicisi.

last
Taşınacak öğe aralığının sonunu gösteren bir giriş yineleyicisi.

dest
Taşınan öğeleri içeren çıkış yineleyicisi.

Açıklamalar

Şablon işlevi, aralıktaki [0, last - first)her N biri için bir kez değerlendirir *(dest + N) = move(*(first + N)) ve en düşük değerle başlama değerlerini N kesinlikle artırır. Ardından döndürür dest + N. Depolama bölgelerini belirlerseniz ve first belirlersenizdest, dest aralığında [first, last)olmamalıdır.

move_backward

Bir yineleyicinin öğelerini diğerine taşır. Hareket belirli bir aralıktaki son öğeyle başlar ve söz konusu aralıktaki ilk öğeyle biter.

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

Parametreler

first
Öğeleri taşımak için aralığın başlangıcını gösteren bir yineleyici.

last
Öğeleri taşımak için aralığın sonunu gösteren bir yineleyici. Bu öğe taşınmaz.

destEnd
Hedef aralıkta son öğeden bir önceki öğenin konumunu belirleyen çift yönlü yineleyici.

Açıklamalar

Şablon işlevi, aralıktaki [0, last - first)her N biri için bir kez değerlendirir *(destEnd - N - 1) = move(*(last - N - 1)) ve en düşük değerle başlama değerlerini N kesinlikle artırır. Ardından döndürür destEnd - (last - first). Depolama bölgelerini belirlerseniz ve first belirlersenizdestEnd, destEnd aralığında [first, last)olmamalıdır.

moveve move_backward işlevsel olarak taşıma yineleyicisi ile ve copy_backward kullanımıyla copy eşdeğerdir.

next_permutation

Bir aralıktaki öğeleri yeniden sıralar, böylece özgün sıralama varsa, sözcüksel olarak bir sonraki daha büyük permütasyonla değiştirilir. Bir sonraki sözcük temelli sözcük bilgisi, ikili bir koşulla belirtilebilir.

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

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

Parametreler

first
Permütasyon yapılacak aralıktaki ilk öğenin konumunu gösteren çift yönlü yineleyici.

last
Permütasyon yapılacak aralıktaki son öğeyi geçen konumu gösteren çift yönlü yineleyici.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

true sözcüksel olarak sonraki permütasyon mevcutsa ve aralığın özgün sırasını değiştirdiyse; aksi takdirde false, sıralama sözcüksel olarak en küçük permütasyona dönüştürülür.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Varsayılan ikili koşul küçüktür ve sonraki permütasyonun iyi tanımlandığından emin olmak için aralıktaki öğelerin karşılaştırılabilirden küçük olması gerekir.

Karmaşıklık, en fazla (last - first) / 2 değiştirme işlemiyle doğrusaldır.

Örnek

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

Bu ölçütleri karşılayan aralıktaki dizinin n. öğesini doğru bir şekilde bularak bir öğe aralığını bölümler: Önündeki tüm öğeler ona eşit veya ondan küçüktür ve onu izleyen tüm öğeler ona eşit veya ondan büyüktür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bölümlenecek aralıktaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

nth
Bölümün sınırında doğru sıralanacak öğenin konumunu ele alan rastgele erişim yineleyicisi.

last
Bölümlenecek aralıktaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Algoritma, nth_element n. öğenin her iki tarafındaki alt düzenlerdeki öğelerin sıralanacağını garanti etmez. Böylece, belirli bir öğenin altındaki aralıktaki öğeleri sıralayan değerinden daha az garanti partial_sortverir ve alt aralığın sıralanması gerekmeyen öğelere partial_sort daha hızlı bir alternatif olarak kullanılabilir.

Öğeler eşdeğerdir, ancak ikisi de diğerinden küçük değilse eşit olmayabilir.

Sıralama karmaşıklığının ortalaması, değerine last - firstgöre doğrusaldır.

Örnek

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

Belirtilen aralıktaki öğeler arasında koşul hiçbir zaman mevcut olmadığında döndürür true .

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bir koşul için öğe aralığını denetlemeye nereden başlayacağını gösteren bir giriş yineleyicisi.

last
Bir öğe aralığının sonunu gösteren giriş yineleyicisi.

pred
Sınanacak koşul. Bu test, koşulu tanımlayan kullanıcı tanımlı bir koşul işlevi nesnesi tarafından sağlanır. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Koşul belirtilen aralıkta en az bir kez algılanırsa ve false koşul algılanırsa döndürürtrue.

Açıklamalar

Şablon işlevi yalnızca aralığındaki bazılarında N koşul her zaman falseise döndürürtrue.[0, last - first)pred(*(first + N))

partial_sort

Bir aralıktaki küçük öğelerin belirtilen sayısını, bir nondescending sırasına göre düzenler. İkili koşul bir sıralama ölçütü sunabilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Sıralanacak aralıktaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

sortEnd
Sıralanacak alt düzendeki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

last
Kısmen sıralanacak aralıktaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Öğeler eşdeğerdir, ancak ikisi de diğerinden küçük değilse eşit olmayabilir. Algoritma sort kararlı değildir ve eşdeğer öğelerin göreli sırasının korunacağını garanti etmez. Algoritma stable_sort bu özgün sıralamayı korur.

Ortalama kısmi sıralama karmaşıklığı O((lastfirst- ) günlüğüdür (sortEndfirst- )).

Örnek

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

Öğeleri bir kaynak aralığından bir hedef aralığa kopyalar, burada kaynak öğeleri daha küçük olana ya da belirtilen başka bir ikili koşula göre sıralanır.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Kaynak aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Kaynak aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

first2
Sıralanmış hedef aralığındaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

last2
Sıralanmış hedef aralığındaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Hedef aralıktaki öğeyi, kaynak aralıktan eklenen son öğenin ötesindeki bir konumu ele alan rastgele erişim yineleyicisi.

Açıklamalar

Kaynak ve hedef aralıkların çakışmaması ve geçerli olması gerekir; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

İkili koşul, eşdeğer olmayan öğelerin sıralanması, ancak eşdeğer olan öğelerin sıralanmaması için katı bir zayıf sıralama sağlamalıdır. İki öğe küçüktür altında eşdeğerdir, ancak ikisi de diğerinden küçük değilse eşit olmayabilir.

Örnek

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

Bir aralıktaki öğeleri iki ayrık kümeye sınıflandırır ve bu öğeler birli koşulu yerine getirerek onu karşılamayanlardan önce olur.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bölümlenecek aralıktaki ilk öğenin konumunu ele alan çift yönlü yineleyici.

last
Bölümlenecek aralıktaki son öğeyi geçen konumu ele alan çift yönlü yineleyici.

pred
Bir öğe sınıflandırılacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

Koşul koşulunu karşılamamak için aralıktaki ilk öğenin konumunu ele alan çift yönlü yineleyici.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

ve öğeleri a eşdeğerdir, ancak her ikisi de pred( a, b ) false ise ve pred( b, a ) false ise eşit olmayabilir; burada pred parametre tarafından belirtilen koşuldur.b Algoritma partition kararlı değildir ve eşdeğer öğelerin göreli sırasının korunacağını garanti etmez. Algoritma stable_partition bu özgün sıralamayı korur.

Karmaşıklık doğrusaldır: ve en çok (last - first) değiştirme uygulamaları pred(last - first)/2 vardır.

Örnek

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

Koşulun bir hedefe, koşulun ise true başka bir hedefe ait olduğu false öğeleri kopyalar. Öğeler belirtilen bir aralıktan gelmelidir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Koşulu denetlemek için aralığın başlangıcını gösteren giriş yineleyicisi.

last
Aralığın sonunu gösteren giriş yineleyicisi.

dest1
kullanılarak predtest edilen bir koşul için true döndüren öğeleri kopyalamak için kullanılan bir çıkış yineleyicisi.

dest2
kullanılarak predtest edilen bir koşul için false döndüren öğeleri kopyalamak için kullanılan bir çıkış yineleyicisi.

pred
Sınanacak koşul. Test, test edilecek koşulu tanımlayan kullanıcı tanımlı bir koşul işlevi nesnesi tarafından sağlanır. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Açıklamalar

Şablon işlevi içindeki her öğeyi X[first,last)*dest1++ true ise pred(X) veya değilse olarak *dest2++ kopyalar. döndürür pair<OutputIterator1, OutputIterator2>(dest1, dest2).

partition_point

Belirtilen aralıktaki koşulu karşılamayan ilk öğeyi döndürür. Öğeler, koşulu karşılayanların olmayanlardan önce gelmesi için sıralanır.

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

Parametreler

first
Koşulu ForwardIterator denetlemek için aralığın başlangıcını gösteren bir.

last
Aralığın ForwardIterator sonunu gösteren bir.

pred
Sınanacak koşul. Test, aranmakta olan öğe tarafından karşılanacak koşulu tanımlayan kullanıcı tanımlı bir koşul işlev nesnesi tarafından sağlanır. Birli koşul tek bir bağımsız değişken alır ve veya falsedöndürürtrue.

Dönüş değeri

tarafından predtest edilen koşulu karşılamayan ilk öğeye başvuran veya bulunamazsa döndüren bir ForwardIterator döndürürlast.

Açıklamalar

Şablon işlevi, içindeki [first, last)pred(*it)falseilk yineleyiciyi it bulur. Sıra tarafından predsıralanmalıdır.

pop_heap

En büyük öğeyi bir yığının önünden aralıktaki bir sonraki son konuma kaldırır ve ardından kalan öğelerden yeni bir yığın oluşturur.

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

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

Parametreler

first
Yığındaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

last
Yığındaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

Algoritma pop_heap , push_heap algoritması tarafından gerçekleştirilen işlemin tersidir ve bir aralığın sonraki son konumundaki bir öğe, yığına eklenen öğenin yığında bulunan öğelerden daha büyük olması durumunda aralıktaki önceki öğelerden oluşan bir yığına eklenir.

Yığınların iki özelliği vardır:

• İlk öğe her zaman en büyük öğedir.

• Öğeler logaritmik zamanda eklenebilir veya kaldırılabilir.

Yığınlar, öncelik kuyruklarını uygulamak için ideal bir yoldur ve C++ Standart Kitaplık kapsayıcı bağdaştırıcısı priority_queue Sınıfı'nın uygulanmasında kullanılır.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Sonunda yeni eklenen öğeyi dışlayan aralık bir yığın olmalıdır.

Karmaşıklık logaritmiktir ve en fazla log (last - first) karşılaştırmayı gerektirmektedir.

Örnek

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

Bir aralıktaki öğeleri yeniden sıralar, böylece özgün sıralama, varsa sözcüksel olarak önceki daha büyük permütasyonla değiştirilir. İkili koşul, sözcük temelli olarak öncekinin duyusunun belirtilmesine neden olabilir.

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

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

Parametreler

first
Permütasyon yapılacak aralıktaki ilk öğenin konumunu gösteren çift yönlü yineleyici.

last
Permütasyon yapılacak aralıktaki son öğeyi geçen konumu gösteren çift yönlü yineleyici.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

true sözcük temelli olarak önceki permütasyon mevcutsa ve aralığın özgün sırasını değiştirdiyse; aksi takdirde false, bu durumda sıralama sözcüksel olarak en büyük permütasyona dönüştürülür.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Varsayılan ikili koşul küçüktür ve önceki permütasyonun iyi tanımlandığından emin olmak için aralıktaki öğelerin karşılaştırılabilirden küçük olması gerekir.

Karmaşıklık doğrusaldır ve en fazla (last - first)/2 değiştirme işlemi yapılır.

Örnek

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

Aralığın sonundaki bir öğeyi aralıktaki önceki öğeleri içeren mevcut yığına ekler.

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

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

Parametreler

first
Yığındaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

last
Yığına dönüştürülecek aralıktaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğunu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

öğesi önce var olan bir yığının sonuna geri gönderilmelidir ve ardından bu öğeyi mevcut yığına eklemek için algoritma kullanılır.

Yığınların iki özelliği vardır:

• İlk öğe her zaman en büyük öğedir.

• Öğeler logaritmik zamanda eklenebilir veya kaldırılabilir.

Yığınlar, öncelik kuyruklarını uygulamak için ideal bir yoldur ve C++ Standart Kitaplık kapsayıcı bağdaştırıcısı priority_queue Sınıfı'nın uygulanmasında kullanılır.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Sonunda yeni eklenen öğeyi dışlayan aralık bir yığın olmalıdır.

Karmaşıklık logaritmiktir ve en fazla log(last - first) karşılaştırmayı gerektirmektedir.

Örnek

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

std::random_shuffle() işlevi kullanım dışıdır, ile std::shuffledeğiştirilir. Kod örneği ve daha fazla bilgi için bkz <random> . ve Stack Overflow gönderisi C++14'te yöntemler neden std::random_shuffle kullanım dışı bırakılıyor?.

remove

Belirtilen değeri, kalan öğelerin sırasını bozmadan belirli bir aralıktan kaldırır. Belirtilen değerden bağımsız yeni bir aralığın sonunu döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin kaldırıldığı aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Öğelerin kaldırıldığı aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

value
Aralıktan kaldırılacak değer.

Dönüş değeri

Değiştirilen aralığın yeni bitiş konumunu ele alan bir ileriye doğru yineleyici, belirtilen değerden bağımsız olarak artık dizisinin son öğesini geçti.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Kaldırılmayan öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Eşitlik için () karşılaştırmalar yaparlast - first.

sınıfı, list işaretçileri de yeniden bağlayan öğesinin removedaha verimli bir üye işlevi sürümüne sahiptir.

Örnek

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

Belirtilen değerin öğelerinin kopyalanmaması dışında, kalan öğelerin sırasını bozmadan öğeleri kaynak aralıktan hedef aralığa kopyalar. Yeni hedef aralığın sonunu döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin kaldırıldığı aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Öğelerin kaldırıldığı aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
Öğelerin kaldırıldığı hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

value
Aralıktan kaldırılacak değer.

Dönüş değeri

Hedef aralığın yeni bitiş konumunu ele alan bir ileriye doğru yineleyici, belirtilen değerden bağımsız olarak, artık sıranın kopyasının son öğesini geçmiştir.

Açıklamalar

Başvuruda bulunılan kaynak ve hedef aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Hedef aralıkta, belirtilen değerin öğeleri kaldırıldıktan sonra kopyalanacak olan artık öğeleri içerecek kadar alan olmalıdır.

Kaldırılmayan öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Eşitlik ve en çok () atama için karşılaştırmalar yaparlast - first(last - first).

Örnek

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

Bir koşula uyan öğeler dışında, öğeleri kaynak aralıktan hedef aralığa kopyalar. Öğeler, kalan öğelerin sırasını bozmadan kopyalanır. Yeni hedef aralığın sonunu döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin kaldırıldığı aralıktaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last
Öğelerin kaldırıldığı aralıktaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
Öğelerin kaldırıldığı hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

pred
Karşılanması gereken birli koşul, bir öğenin değerinin değiştirilmesidir.

Dönüş değeri

Hedef aralığın yeni bitiş konumunu ele alan bir ileriye doğru yineleyici, koşula uyan öğelerden bağımsız olarak, artık dizisinin son öğesini geçti.

Açıklamalar

Başvuruda bulunılan kaynak aralığı geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Hedef aralıkta, belirtilen değerin öğeleri kaldırıldıktan sonra kopyalanacak olan artık öğeleri içerecek kadar alan olmalıdır.

Kaldırılmayan öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Eşitlik ve en çok () atama için karşılaştırmalar yaparlast - first(last - first).

Bu işlevlerin nasıl davrandığını öğrenmek için bkz . İşaretli Yineleyiciler.

Örnek

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

Belirli bir aralıktaki bir koşulu karşılayan öğeleri, kalan öğelerin sırasını bozmadan ortadan kaldırır. Belirtilen değerden bağımsız yeni bir aralığın sonunu döndürür.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin kaldırıldığı aralıktaki ilk öğenin konumunu gösteren ileri doğru yineleyici.

last
Öğelerin kaldırıldığı aralıktaki son öğeyi geçen konuma işaret eden ileriye doğru yineleyici.

pred
Karşılanması gereken birli koşul, bir öğenin değerinin değiştirilmesidir.

Dönüş değeri

Değiştirilen aralığın yeni bitiş konumunu ele alan bir ileriye doğru yineleyici, belirtilen değerden bağımsız olarak artık dizisinin son öğesini geçti.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Kaldırılmayan öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Eşitlik için () karşılaştırmalar yaparlast - first.

Liste, işaretçileri yeniden bağlayan kaldırmanın daha verimli bir üye işlevi sürümüne sahiptir.

Örnek

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

Bir aralıktaki tüm öğeleri inceler ve belirtilen bir değerle eşleşiyorsa değiştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin değiştirildiği aralıktaki ilk öğenin konumunu gösteren ileri doğru yineleyici.

last
Öğelerin değiştirildiği aralıktaki son öğeyi geçen konuma işaret eden ileriye doğru yineleyici.

oldVal
Değiştirilen öğelerin eski değeri.

newVal
Eski değere sahip öğelere atanan yeni değer.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Değiştirilmeyen öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Yeni değerlerin eşitlik ve en çok ( - firstlast) ataması için karşılaştırmalar yapar.last - first

Örnek

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

Bir kaynak aralığındaki her öğeyi inceler ve sonuç yeni bir hedef aralığına kopyalanırken öğe belirtilen değerle eşleşiyorsa, onu değiştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin değiştirildiği aralıktaki ilk öğenin konumunu gösteren bir giriş yineleyicisi.

last
Öğelerin değiştirildiği aralıktaki son öğeyi geçen konumu gösteren bir giriş yineleyicisi.

result
Değişen öğe sırasının kopyalandığı hedef aralıktaki ilk öğeye işaret eden bir çıkış yineleyicisi.

oldVal
Değiştirilen öğelerin eski değeri.

newVal
Eski değere sahip öğelere atanan yeni değer.

Dönüş değeri

Değiştirilen öğe dizisinin kopyalandığı hedef aralıktaki son öğeyi geçen konumu gösteren bir çıkış yineleyicisi.

Açıklamalar

Başvurulan kaynak ve hedef aralıkların çakışmaması ve her ikisinin de geçerli olması gerekir: tüm işaretçiler başvurulamamalıdır ve sıralar içinde son konuma ilkinden artımlı olarak ulaşılabilir.

Değiştirilmeyen öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Yeni değerlerin eşitlik ve en çok (last - first) ataması için karşılaştırmalar yaparlast - first.

Örnek

// 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() Önceki koddaki çağrı nedeniyle çıkışınız farklı olabilir.

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

Bir kaynak aralığındaki her öğeyi inceler ve sonuç yeni bir hedef aralığına kopyalanırken öğe belirtilen bir koşulu karşılıyorsa, onu değiştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin değiştirildiği aralıktaki ilk öğenin konumunu gösteren bir giriş yineleyicisi.

last
Öğelerin değiştirildiği aralıktaki son öğeyi geçen konumu gösteren bir giriş yineleyicisi.

result
Öğelerin kopyalandığı hedef aralıktaki ilk öğenin konumunu gösteren bir çıkış yineleyicisi.

pred
Karşılanması gereken birli koşul, bir öğenin değerinin değiştirilmesidir.

value
Eski değeri koşulu karşılayan öğelere atanan yeni değer.

Dönüş değeri

Değiştirilen öğe dizisinin kopyalandığı hedef aralıktaki son öğeyi geçen konumu gösteren bir çıkış yineleyicisi.

Açıklamalar

Başvurulan kaynak ve hedef aralıkların çakışmaması ve her ikisinin de geçerli olması gerekir: tüm işaretçiler başvurulamamalıdır ve sıralar içinde son konuma ilkinden artımlı olarak ulaşılabilir.

Değiştirilmeyen öğelerin sırası kararlı kalır.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Yeni değerlerin eşitlik ve en çok ( - firstlast) ataması için karşılaştırmalar yapar.last - first

Örnek

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

Bir aralıktaki tüm öğeleri inceler ve belirtilen bir koşulu karşılıyorsa değiştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin değiştirildiği aralıktaki ilk öğenin konumunu gösteren ileri doğru yineleyici.

last
Öğelerin değiştirildiği aralıktaki son öğeyi geçmiş konumuna işaret eden bir yineleyici.

pred
Karşılanması gereken birli koşul, bir öğenin değerinin değiştirilmesidir.

value
Eski değeri koşulu karşılayan öğelere atanan yeni değer.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Değiştirilmeyen öğelerin sırası kararlı kalır.

Algoritma replace_if , belirtilen sabit değere eşitlik yerine herhangi bir koşulun belirtilmesine izin veren algoritmanın replacegenelleştirilmesidir.

operator== Öğeler arasındaki eşitliği belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi uygulamalıdır.

Karmaşıklık doğrusaldır. Yeni değerlerin eşitlik ve en çok ( - firstlast) ataması için karşılaştırmalar yapar.last - first

Örnek

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

Bir aralık içindeki öğelerin sırasını tersine çevirir.

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

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Öğelerin permütasyonunun gerçekleştirildiği aralıktaki ilk öğenin konumunu gösteren çift yönlü yineleyici.

last
Öğelerin permütasyonunun gerçekleştirildiği aralıktaki son öğeyi geçmiş konumuna işaret eden çift yönlü bir yineleyici.

Açıklamalar

Başvuruda bulunılan kaynak aralığı geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Örnek

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

Bir hedef aralığına kopyalanırken bir kaynak aralığındaki öğelerin sırasını tersine çevirir

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Kaynak aralıktaki öğelerin permütasyonunun gerçekleştirildiği ilk öğenin konumunu gösteren çift yönlü yineleyici.

last
Öğelerin permütasyonunun gerçekleştirildiği kaynak aralığındaki son öğeyi geçmiş konumuna işaret eden çift yönlü bir yineleyici.

result
Öğelerin kopyalandığı hedef aralıktaki ilk öğenin konumunu gösteren bir çıkış yineleyicisi.

Dönüş değeri

Değiştirilen öğe dizisinin kopyalandığı hedef aralıktaki son öğeyi geçen konumu gösteren bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan kaynak ve hedef aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Örnek

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

İki bitişik aralık içindeki öğeleri birbiriyle değiştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Döndürülecek aralıktaki ilk öğenin konumunu ele alan ileri doğru yineleyici.

middle
Aralığın ikinci bölümündeki ilk öğenin konumunu ele alan ve öğelerinin aralığın ilk bölümündekilerle değiştirileceği sınırı tanımlayan ileriye doğru yineleyici.

last
Döndürülecek aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

Açıklamalar

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Karmaşıklık doğrusaldır. En fazla (last - first) değiştirme işlemi yapar.

Örnek

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

Bir kaynak aralık içindeki iki bitişik aralıktaki öğeleri birbiriyle değiştirir ve sonucu bir hedef aralığına kopyalar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Döndürülecek aralıktaki ilk öğenin konumunu ele alan ileri doğru yineleyici.

middle
Aralığın ikinci bölümündeki ilk öğenin konumunu ele alan ve öğelerinin aralığın ilk bölümündekilerle değiştirileceği sınırı tanımlayan ileriye doğru yineleyici.

last
Döndürülecek aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

result
Hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

Dönüş değeri

Hedef aralıktaki son öğeyi geçen konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Karmaşıklık doğrusaldır. En fazla (last - first) değiştirme işlemi yapar.

Örnek

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

Öğeleri belirli bir öğe dizisindeki öğelere eşit olan veya öğeleri belirli bir dizideki öğelerle ikili koşul tarafından belirtilen bir anlamda eşdeğer olan bir hedef aralık içinde bir dizinin ilk oluşumunu arar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last1
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

first2
Eşleştirilecek aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last2
Eşleştirilecek aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

searcher
Aranacak deseni ve kullanılacak arama algoritmasını kapsülleyen arayıcı. Arayanlar hakkında daha fazla bilgi için bkz default_searcher . sınıf, boyer_moore_horspool_searcher sınıf ve boyer_moore_searcher sınıf.

Dönüş değeri

Belirtilen diziyle eşleşen veya bir ikili koşul tarafından belirtilen bir anlamda eşdeğer olan ilk alt dizinin ilk öğesinin konumunu ele alan ileriye doğru yineleyici.

Açıklamalar

Bir operator== öğe ile belirtilen değer arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi oluşturmalıdır.

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Ortalama karmaşıklık, arama yapılan aralığın boyutuna göre doğrusaldır. En kötü durum karmaşıklığı, aranmakta olan dizinin boyutuna göre de doğrusaldır.

Örnek

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

Belirli bir değere veya ikili bir koşula göre belirtilen değerle bir ilişkiye sahip olan öğelerin belirli bir sayısının aralığındaki ilk diziyi arar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Aranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last1
Aranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

count
Aranmakta olan alt sorgunun boyutu.

value
Aranmakta olan dizideki öğelerin değeri.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Belirtilen diziyle eşleşen veya bir ikili koşul tarafından belirtilen bir anlamda eşdeğer olan ilk alt dizinin ilk öğesinin konumunu ele alan ileriye doğru yineleyici.

Açıklamalar

Bir operator== öğe ile belirtilen değer arasındaki eşleşmeyi belirlemek için kullanılan, işlenenleri arasında bir denklik ilişkisi oluşturmalıdır.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Karmaşıklık, aramanın boyutuna göre doğrusaldır.

Örnek

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

Tek bir sıralanmış kaynak aralığına ait olan, ancak ikinci bir sıralanmış kaynak aralığına ait olmayan tüm öğeleri tek, sıralanmış bir hedef aralıkta birleştirir. İkili koşul sıralama ölçütlerini belirtebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Birleştirilecek ve iki kaynak aralığın farkını temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Birleştirilecek ve iki kaynak aralığın farkını temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

first2
Birleştirilecek ve iki kaynak aralığının farkını temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının ikincisinde birinci öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Birleştirilecek ve iki kaynak aralığın farkını temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının saniyesinde son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
İki kaynak aralığının iki kaynak aralığının farkını temsil eden tek bir sıralanmış aralıkta birleştirileceği hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçükse ve false aksi halde döndürülmelidirtrue.

Dönüş değeri

İki kaynak aralığının farkını temsil eden sıralanmış hedef aralığındaki son öğeden önceki konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralıkları geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Hedef aralığın her iki kaynak aralığıyla da çakışmaması ve ilk kaynak aralığı içerecek kadar büyük olması gerekir.

Sıralanmış kaynak aralıklarının her biri algoritmanın set_difference uygulanması için bir önkoşul olarak, birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılmak üzere aynı sıralamaya göre düzenlenmelidir.

Her aralıktaki öğelerin göreli sırası hedef aralıkta korunduğu için işlem kararlıdır. Kaynak aralıklar algoritma birleştirme tarafından değiştirilmez.

Giriş yineleyicilerinin değer türlerinin sıralanması için karşılaştırılabilirden az olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan. Her iki kaynak aralıkta da eşdeğer öğeler olduğunda, ilk aralıktaki öğeler hedef aralıktaki ikinci kaynak aralığından önce gelen öğelerdir. Kaynak aralıklar, birinci kaynak aralığında ikinciye göre daha fazla öğe olacak şekilde bir öğenin yinelemelerini içeriyorsa, hedef aralık bu öğelerin ilk kaynak aralığındaki oluşumlarının bu öğelerin ikinci kaynak aralığındaki oluşumlarını aştığı sayıyı içerir.

Algoritmanın karmaşıklığı, olmayan kaynak aralıkları için en fazla 2 * ((last1 - first1) + (last2 - first2)) - 1 karşılaştırma ile doğrusaldır.

Örnek

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

Her iki sıralanmış kaynak aralığa sahip öğelerin tümünü tek, sıralanmış bir aralıkta birleştirir, burada sıralama ölçütü bir ikili koşula göre belirtilebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Birleştirilecek ve iki kaynak aralığının kesişimini temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Birleştirilecek ve iki kaynak aralığın kesişimini temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki son öğeyi geçmiş konumu ele alan bir giriş yineleyicisi.

first2
Birleştirilecek ve iki kaynak aralığının kesişimini temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının ikincisinde ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Birleştirilecek ve iki kaynak aralığının kesişimini temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının saniyesinde son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
İki kaynak aralığın iki kaynak aralığının kesişimini temsil eden tek bir sıralanmış aralıkta birleştirileceği hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçükse ve false aksi halde döndürülmelidirtrue.

Dönüş değeri

İki kaynak aralığının kesişimini temsil eden sıralanmış hedef aralığındaki son öğeden önceki konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralıkları geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Hedef aralık, kaynak aralıklardan herhangi biriyle çakışmamalı ve hedef aralığı içerecek kadar büyük olmalıdır.

Sıralanmış kaynak aralıklarının her biri birleştirme algoritmasının uygulanması için bir önkoşul olarak, birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılmak üzere aynı sıralamaya göre düzenlenmelidir.

Her aralıktaki öğelerin göreli sırası hedef aralıkta korunduğu için işlem kararlıdır. Kaynak aralıklar algoritma tarafından değiştirilmez.

Giriş yineleyicilerinin değer türlerinin sıralanması için karşılaştırılabilirden az olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan. Her iki kaynak aralıkta da eşdeğer öğeler olduğunda, ilk aralıktaki öğeler hedef aralıktaki ikinci kaynak aralığından önce gelen öğelerdir. Kaynak aralıklar bir öğenin yinelemelerini içeriyorsa, hedef aralık her iki kaynak aralıkta da bu öğelerin en fazla sayısını içerir.

Algoritmanın karmaşıklığı, olmayan kaynak aralıkları için en fazla 2 * ((last1 - first1) + (last2 - first2)) - 1 karşılaştırma ile doğrusaldır.

Örnek

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

Sıralanmış kaynak aralıklarının tek bir sıralanmış hedef aralığına ait olan ancak her ikisine de ait olmayan tüm öğeleri birleştirir. İkili koşul sıralama ölçütlerini belirtebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Birleştirilecek ve iki kaynak aralığının simetrik farkını temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Birleştirilecek ve iki kaynak aralığının simetrik farkını temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

first2
Birleştirilecek ve iki kaynak aralığının simetrik farkını temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının ikincisinde ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Birleştirilecek ve iki kaynak aralığının simetrik farkını temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının saniyesinde son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
İki kaynak aralığının iki kaynak aralığının simetrik farkını temsil eden tek bir sıralanmış aralıkta birleştirileceği hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçükse ve false aksi halde döndürülmelidirtrue.

Dönüş değeri

İki kaynak aralığının simetrik farkını temsil eden sıralanmış hedef aralığındaki son öğeden önceki konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralıkları geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Hedef aralık, kaynak aralıklardan herhangi biriyle çakışmamalı ve hedef aralığı içerecek kadar büyük olmalıdır.

Sıralanmış kaynak aralıklarının her biri algoritmanın merge* uygulanması için bir önkoşul olarak, birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılmak üzere aynı sıralamaya göre düzenlenmelidir.

Her aralıktaki öğelerin göreli sırası hedef aralıkta korunduğu için işlem kararlıdır. Kaynak aralıklar algoritma birleştirme tarafından değiştirilmez.

Giriş yineleyicilerinin değer türlerinin sıralanması için karşılaştırılabilirden az olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan. Her iki kaynak aralıkta da eşdeğer öğeler olduğunda, ilk aralıktaki öğeler hedef aralıktaki ikinci kaynak aralığından önce gelen öğelerdir. Kaynak aralıklar bir öğenin yinelemelerini içeriyorsa, hedef aralık, kaynak aralıklardan birinde bu öğelerin oluşumlarının ikinci kaynak aralıktaki bu öğelerin oluşumlarını aştığı sayının mutlak değerini içerir.

Algoritmanın karmaşıklığı, olmayan kaynak aralıkları için en fazla 2 * ((last1 - first1) + (last2 - first2)) - 1 karşılaştırma ile doğrusaldır.

Örnek

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

İki sıralanmış kaynak aralığından en az birine ait olan tüm öğeleri tek, sıralanmış bir hedef aralıkta birleştirir. İkili koşul sıralama ölçütlerini belirtebilir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Birleştirilecek ve iki kaynak aralığın birleşimini temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Birleştirilecek ve iki kaynak aralığının birleşimini temsil eden tek bir aralığa sıralanacak iki sıralanmış kaynak aralığının ilkindeki son öğeyi geçmiş konumu ele alan bir giriş yineleyicisi.

first2
Birleştirilecek ve iki kaynak aralığın birleşimini temsil eden tek bir aralığa sıralanacak ardışık sıralanmış iki kaynak aralığın ikincisinde birinci öğenin konumunu ele alan bir giriş yineleyicisi.

last2
Birleştirilecek ve iki kaynak aralığının birleşimini temsil eden tek bir aralığa sıralanacak iki ardışık sıralanmış kaynak aralığının saniyesinde son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

result
İki kaynak aralığının birleştirileceği hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi, iki kaynak aralığın birleşimini temsil eden tek bir sıralanmış aralıkta birleştirilecek.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve ilk öğe ikinci öğeden küçükse ve false aksi halde döndürülmelidirtrue.

Dönüş değeri

İki kaynak aralığının birleşimini temsil eden sıralanmış hedef aralığındaki son öğeden önceki konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralıkları geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır.

Hedef aralık, kaynak aralıklardan herhangi biriyle çakışmamalı ve hedef aralığı içerecek kadar büyük olmalıdır.

Sıralanmış kaynak aralıklarının her biri algoritmanın merge uygulanması için bir önkoşul olarak, birleştirilmiş aralıkları sıralamak için algoritma tarafından kullanılmak üzere aynı sıralamaya göre düzenlenmelidir.

Her aralıktaki öğelerin göreli sırası hedef aralıkta korunduğu için işlem kararlıdır. Kaynak aralıklar algoritması mergetarafından değiştirilmez.

Giriş yineleyicilerinin değer türlerinin sıralanması için karşılaştırılabilirden az olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan. Her iki kaynak aralıkta da eşdeğer öğeler olduğunda, ilk aralıktaki öğeler hedef aralıktaki ikinci kaynak aralığından önce gelen öğelerdir. Kaynak aralıklar bir öğenin yinelemelerini içeriyorsa, hedef aralık her iki kaynak aralıkta da bu öğelerin en fazla sayısını içerir.

Algoritmanın karmaşıklığı, çoğu 2 * ((last1 - first1) + (last2 - first2)) - 1 karşılaştırmada doğrusaldır.

Örnek

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

Rastgele bir sayı oluşturucu kullanarak belirli bir aralık için öğeleri karıştır (yeniden düzenler).

template<class RandomAccessIterator, class UniformRandomNumberGenerator>
void shuffle(
    RandomAccessIterator first,
    RandomAccessIterator last,
    UniformRandomNumberGenerator&& gen);

Parametreler

first
Karıştırılacak aralıktaki ilk öğeye (dahil) bir yineleyici. ve ValueSwappablegereksinimlerini karşılamalıdırRandomAccessIterator.

last
Karıştırılacak aralıktaki son öğeye bir yineleyici, özel. ve ValueSwappablegereksinimlerini karşılamalıdırRandomAccessIterator.

gen
İşlevin işlem için kullanacağı rastgele sayı oluşturucu shuffle() . Gereksinimlerini karşılaması UniformRandomNumberGeneratorgerekir.

Açıklamalar

Daha fazla bilgi ve kullanan shuffle()bir kod örneği için bkz <random>. .

sort

Belirtilen bir aralıktaki öğeleri azalmayan şekilde veya bir ikili koşul tarafından belirtilen bir sıralama ölçütüne göre düzenler.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Sıralanacak aralıktaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

last
Sıralanacak aralıktaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Bu ikili koşul iki bağımsız değişken alır ve iki bağımsız değişken sıralıysa ve false değilse döndürürtrue. Bu karşılaştırıcı işlevi, dizideki öğe çiftlerine katı bir zayıf sıralama uygulamalıdır. Daha fazla bilgi için bkz . Algoritmalar.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Öğeler eşdeğerdir, ancak ikisi de diğerinden küçük değilse eşit olmayabilir. Algoritma sort kararlı değildir ve bu nedenle eşdeğer öğelerin göreli sırasının korunacağını garanti etmez. Algoritma stable_sort bu özgün sıralamayı korur.

Sıralama karmaşıklığının ortalaması , burada N - firstlast = ' dir.O( N log N )

Örnek

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

Bir yığını sıralanmış bir aralığa dönüştürür.

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

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

Parametreler

first
Hedef yığındaki ilk öğenin konumunu ele alan rastgele erişim yineleyicisi.

last
Hedef yığındaki son öğeyi geçen konumu ele alan rastgele erişim yineleyicisi.

pred
Bir öğenin başka bir öğeden küçük olduğu duyuyu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

Yığınların iki özelliği vardır:

• İlk öğe her zaman en büyük öğedir.

• Öğeler logaritmik zamanda eklenebilir veya kaldırılabilir.

Uygulamadan sonra bu algoritma uygulandıysa, uygulandığı aralık artık yığın değildir.

sort_heap kararlı bir sıralama değildir çünkü eşdeğer öğelerin göreli sırası mutlaka korunmaz.

Yığınlar, öncelik kuyruklarını uygulamak için ideal bir yoldur ve C++ Standart Kitaplık kapsayıcı bağdaştırıcısı priority_queue Sınıfının uygulanmasında kullanılır.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Karmaşıklık en N log Nfazla olan , burada N = last - first.

Örnek

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

Bir aralıktaki öğeleri iki ayrık kümeye sınıflandırır; tekli bir koşulu karşılayan öğeler, onu karşılamayanlardan önce, eşdeğer öğelerin göreli sırasını korur.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Bölümlenecek aralıktaki ilk öğenin konumunu ele alan çift yönlü yineleyici.

last
Bölümlenecek aralıktaki son öğeyi geçen konumu ele alan çift yönlü yineleyici.

pred
Bir öğe sınıflandırılacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. Birli koşul tek bir bağımsız değişken alır ve memnunsanız veya false memnun değilse döndürürtrue.

Dönüş değeri

Koşul koşulunu karşılamamak için aralıktaki ilk öğenin konumunu ele alan çift yönlü yineleyici.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

a ve b öğeleri eşdeğerdir, ancak her ikisi de pred( a, b ) false ise ve pred( b, a ) false ise, parametre tarafından belirtilen koşul burada pred eşit değildir. Algoritma stable_partition kararlıdır ve eşdeğer öğelerin göreli sırasının korunacağını garanti eder. Algoritmanın partition bu özgün sıralamayı koruması şart değildir.

Örnek

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

Belirtilen bir aralıktaki öğeleri azalmayan şekilde veya bir ikili koşul tarafından belirtilen bir sıralama ölçütüne göre düzenler. Eşdeğer öğelerin göreli sıralamasını korur.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Sıralanacak aralıktaki ilk öğenin konumunu ele alan çift yönlü yineleyici.

last
Sıralanacak aralıktaki son öğeyi geçen konumu ele alan çift yönlü yineleyici.

pred
Sıralamadaki ardışık öğeler tarafından karşılanacak karşılaştırma ölçütlerini tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Açıklamalar

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir.

Öğeler eşdeğerdir, ancak ikisi de diğerinden küçük değilse eşit olmayabilir. Algoritma sort kararlıdır ve eşdeğer öğelerin göreli sırasının korunacağını garanti eder.

çalışma zamanı karmaşıklığı stable_sort kullanılabilir bellek miktarına bağlıdır, ancak en iyi durum (yeterli bellek verildiğinde) O(N log N) ve en kötü durum ise O(N (log N)^2), burada Nfirst = last - olur. Algoritma genellikle değerinden sortstable_sortdaha hızlıdır.

Örnek

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

İlk geçersiz kılma, iki nesnenin değerlerini değiştirir. İkinci geçersiz kılma, iki nesne dizisi arasındaki değerleri değiştirir.

template<class Type>
void swap(
    Type& left,
    Type& right);
template<class Type, size_t N>
void swap(
    Type (& left)[N],
    Type (& right)[N]);

Parametreler

left
İlk geçersiz kılma için, içeriğinin değiş tokuşu yapılan ilk nesne. İkinci geçersiz kılma için, içeriğinin değiş tokuşunu içeren ilk nesne dizisidir.

right
İlk geçersiz kılma için, içeriğinin değiş tokuşunu yapmak için ikinci nesne. İkinci geçersiz kılma için, içeriğinin değiş tokuşu yapılan ikinci nesne dizisi.

Açıklamalar

İlk aşırı yükleme, tek tek nesneler üzerinde çalışacak şekilde tasarlanmıştır. İkinci aşırı yükleme, nesnelerin içeriğini iki dizi arasında değiştirir.

Örnek

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

Bir aralığın öğelerini eşit büyüklükteki bir diğerinin öğeleriyle değiştirir.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Öğeleri değiştirilecek ilk aralığın ilk konumunu gösteren ileriye doğru yineleyici.

last1
Öğeleri değiştirilecek olan ilk aralığın son konumunu geçene işaret eden ileriye doğru yineleyici.

first2
Öğeleri değiştirilecek ikinci aralığın ilk konumuna işaret eden ileriye doğru yineleyici.

Dönüş değeri

Öğeleri değiştirilecek ikinci aralığın son konumunu geçene işaret eden ileriye doğru yineleyici.

Açıklamalar

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir. İkinci aralığın ilk aralık kadar büyük olması gerekir.

Karmaşıklık, son1 ilk1 - değiştirme işleminin gerçekleştirilmesiyle doğrusaldır. Aynı türdeki kapsayıcılardan öğeler değiştiriliyorsa, üye işlevinin swap genellikle sabit karmaşıklığı olduğundan bu kapsayıcıdaki üye işlevi kullanılmalıdır.

Örnek

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

Belirtilen işlev nesnesini bir kaynak aralıktaki her öğeye veya iki kaynak aralıktaki bir öğe çiftine uygular. Ardından işlev nesnesinin dönüş değerlerini bir hedef aralığa kopyalar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first1
Üzerinde çalışılması gereken ilk kaynak aralığındaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

last1
Üzerinde çalışılması gereken ilk kaynak aralığındaki son öğeyi geçen konumu ele alan bir giriş yineleyicisi.

first2
üzerinde çalışılması gereken ikinci kaynak aralığındaki ilk öğenin konumunu ele alan bir giriş yineleyicisi.

result
Hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

func
İlk kaynak aralığındaki her öğeye uygulamak için algoritmanın ilk sürümünde kullanılan kullanıcı tanımlı bir tekli işlev nesnesi veya iki kaynak aralığına çift yönlü olarak uygulanan algoritmanın ikinci sürümünde kullanılan kullanıcı tanımlı (UD) ikili işlev nesnesi.

Dönüş değeri

İşlev nesnesi tarafından dönüştürülen çıkış öğelerini alan hedef aralıktaki son öğeyi geçen konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve her bir dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir olmalıdır. Hedef aralığın dönüştürülen kaynak aralığını içerecek kadar büyük olması gerekir.

Sonuç, algoritmanın ilk sürümünde değerine eşit first1 olarak ayarlanırsa, kaynak ve hedef aralıklar aynı olur ve sıra yerinde değiştirilir. Ancak [ resultfirst1 + 1, last1) aralığındaki bir konumu ele almayabilir.

Karmaşıklık doğrusaldır. En fazla (last1 - first1) karşılaştırma yapar.

Örnek

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

Belirtilen aralıkta yan yana olan yinelenen öğeleri kaldırır.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Yinelenen kaldırma için taranacak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Yinelenen kaldırma için taranacak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Ardışık yineleme içermeyen değiştirilmiş sıranın yeni sonuna iletilen yineleyici, kaldırılmayan son öğeden bir önceki konumu ele alır.

Açıklamalar

Algoritmanın her iki biçimi de ardışık bir eşit öğe çiftinin ikinci yinelemesini kaldırır.

Algoritmanın işlemi kararlıdır, böylece istenmeyen öğelerin göreli sırası değiştirilmez.

Başvuruda bulunılan aralık geçerli olmalıdır; tüm işaretçiler başvurulamaz olmalıdır ve dizi içinde son konuma ilk konumdan artımlı olarak ulaşılabilir. Dizideki öğelerin sayısı algoritma unique tarafından değiştirilmez ve değiştirilen sıranın sonunun ötesindeki öğeler başvurulamaz ancak belirtilmez.

Karmaşıklık doğrusaldır ve karşılaştırmalar gerekir (last - first) - 1 .

List, daha iyi performans gösterebilecek daha verimli bir üye işlevi "benzersiz" sağlar.

Bu algoritmalar ilişkilendirilebilir bir kapsayıcıda kullanılamaz.

Örnek

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

Bir kaynak aralıktaki öğeleri, yan yana olan yinelenen öğeler dışında bir hedef aralığa kopyalar.

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

Parametreler

exec
Kullanılacak yürütme ilkesi.

first
Kopyalanacak kaynak aralıktaki ilk öğenin konumunu ele alan ileriye doğru yineleyici.

last
Kopyalanacak kaynak aralıktaki son öğeyi geçen konumu ele alan ileriye doğru yineleyici.

result
Ardışık yinelemelerin kaldırıldığı kopyayı alan hedef aralıktaki ilk öğenin konumunu ele alan bir çıkış yineleyicisi.

pred
İki öğe eşdeğer olarak alınacaksa, karşılanacak koşulu tanımlayan kullanıcı tanımlı koşul işlev nesnesi. İkili koşul iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Ardışık yinelemelerin kaldırıldığı kopyayı alan hedef aralıktaki son öğeden önceki konumu ele alan bir çıkış yineleyicisi.

Açıklamalar

Algoritmanın her iki biçimi de ardışık bir eşit öğe çiftinin ikinci yinelemesini kaldırır.

Algoritmanın işlemi kararlıdır, böylece istenmeyen öğelerin göreli sırası değiştirilmez.

Başvuruda bulunılan aralıklar geçerli olmalıdır; tüm işaretçiler başvurulamamalıdır ve bir dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir.

Karmaşıklık doğrusaldır ve karşılaştırmalast - first gerektirir.

Örnek

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

Belirtilen değerden büyük bir değere sahip sıralı aralıktaki ilk öğenin konumunu bulur. İkili koşul sıralama ölçütlerini belirtir.

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

Parametreler

first
Aranacak aralıktaki ilk öğenin konumu.

last
Aranacak aralıktaki son öğeyi geçen konum.

value
Sıralı aralıktaki değerin, döndürülen yineleyici tarafından ele alınan öğenin değeriyle aşılması gerekir.

pred
Bir öğenin başka bir öğeden daha az olduğu duyuyu tanımlayan kullanıcı tanımlı karşılaştırma koşulu işlev nesnesi. Karşılaştırma koşulu iki bağımsız değişken alır ve tatmin olduğunda ve false karşılanmadığında döndürürtrue.

Dönüş değeri

Bir yineleyici, belirtilen değerden daha büyük bir değere sahip olan ilk öğenin konumuna iletildi.

Açıklamalar

Başvuruda bulunılan sıralanmış kaynak aralığı geçerli olmalıdır; tüm yineleyiciler başvurulamamalıdır ve dizi içinde son konuma ilkinden artımlı olarak ulaşılabilir olmalıdır.

Sıralanmış aralık, ve kullanımının upper_bound ön koşuludur ve burada sıralama ölçütü karşılaştırma koşulu tarafından belirtilenle aynıdır.

Aralık tarafından upper_bounddeğiştirilmez.

İleriye doğru yineleyicilerin değer türlerinin sıralanabilmesi için daha az karşılaştırılabilir olması gerekir. Diğer bir deyişle, iki öğe verildiğinde, birinin diğerinden küçük olduğunu veya eşdeğer olduğunu belirleyebilirsiniz. (Burada eşdeğer, ikisinin de diğerinden küçük olmadığı anlamına gelir.) Bu karşılaştırma, eşdeğer olmayan öğeler arasında bir sıralamayla sonuçlanan.

Algoritmanın karmaşıklığı, rastgele erişim yineleyicileri için logaritmiktir ve aksi takdirde doğrusaldır ve adım sayısı (last - first) ile orantılıdır.

Örnek

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