<algorithm> – funkce

adjacent_find

Vyhledá dva sousedící prvky, které jsou buď rovny, nebo splňují zadanou podmínku.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor na pozici prvního prvku v rozsahu, který se má prohledávat.

last
Dopředný iterátor na pozici jedna za posledním prvkem v rozsahu, který se má prohledávat.

pred
Binární predikát poskytující podmínku, která má být splněna hodnotami sousedních prvků v prohledávaném rozsahu.

Vrácená hodnota

Předaný iterátor na první ze sousedních prvků, které se buď navzájem rovnají (v první verzi), nebo které splňují podmínku danou binárním predikátem (ve druhé verzi), pokud je nalezena taková dvojice prvků. V opačném případě se vrátí iterátor odkazující na last .

Poznámky

Algoritmus adjacent_find je nemutující sekvenční algoritmus. Rozsah, který se má prohledávat, musí být platný. Všechny ukazatele musí být odvozitelné a poslední pozice musí být dosažitelná od prvního zvýšením. Časová složitost algoritmu je lineární v počtu prvků obsažených v rozsahu.

Použitý operator== k určení shody mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Příklad

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

Vrátí true , když je podmínka přítomna na každém prvku v daném rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje, kde začít kontrolovat podmínku. Iterátor označuje, kde začíná rozsah prvků.

last
Vstupní iterátor, který označuje konec rozsahu prvků ke kontrole podmínky.

pred
Podmínka, pro která se má testovat. pred je uživatelem definovaný unární predikát objekt funkce, který definuje podmínku, která má být splněna kontrolou prvku. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Vrátí true , pokud je podmínka zjištěna u každého prvku v uvedené oblasti nebo pokud je oblast prázdná, a false jinak.

Poznámky

Funkce šablony vrátí true pouze v případě, že pro každý N v oblasti [0, last - first)je predikát pred(*(first + N)) true.

Příklad

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

Vrátí true , když je podmínka přítomna alespoň jednou v zadaném rozsahu prvků.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje, kde začít kontrolovat rozsah prvků pro podmínku.

last
Vstupní iterátor, který označuje konec rozsahu prvků ke kontrole podmínky.

pred
Podmínka, pro která se má testovat. Tento test poskytuje uživatelem definovaný predikát objekt funkce. Predikát definuje podmínku, která má být splněna testovaným prvkem. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Vrátí true , pokud je podmínka zjištěna alespoň jednou v zadaném rozsahu, false pokud se podmínka nikdy nezjistí.

Poznámky

Funkce šablony vrátí true pouze v případě, že u některých N v oblasti

[0, last - first), predikát pred(*(first + N)) je pravdivý.

Příklad

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

Testuje, zda existuje prvek v seřazené oblasti, která je rovna zadané hodnotě, nebo je ekvivalentní s ní ve smyslu určeném binárním predikátem.

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

Parametry

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

value
Hodnota, která se musí shodovat s hodnotou prvku nebo která musí splňovat podmínku s hodnotou prvku určenou binárním predikátem.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

trueje-li prvek nalezen v oblasti, která je rovna nebo ekvivalentní zadané hodnotě; v opačném případě . false

Poznámky

Seřazený zdrojový rozsah, na který odkazuje, musí být platný; všechny ukazatele musí být dereferencovatelné a v rámci sekvence musí být poslední pozice dosažitelná od prvního přírůstku.

Seřazený rozsah musí být uspořádán jako předběžná podmínka pro použití binary_search algoritmu v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů.

Zdrojové rozsahy nejsou upraveny binary_search.

Typy hodnot předávaných iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky.

Složitost algoritmu je logaritmická pro iterátory náhodného přístupu a lineární v opačném případě s počtem kroků úměrných (last-first).

Příklad

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

Porovná hodnotu s horní a dolní hranicí a vrátí odkaz na hodnotu, pokud je mezi hranicemi nebo odkazem na horní nebo dolní mez, pokud je hodnota nad nebo pod nimi.

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

Parametry

value
Hodnota, která se má porovnat s upper a lower.

lower
Dolní mez hodnot, na které se uchytá value .

upper
Horní mez hodnot, na které se uchytá value .

pred
Predikát použitý k porovnání value s lower nebo upper. Predikát porovnání přebírá dva argumenty a vrátí, true pokud je první v určitém smyslu menší než druhý, a jinak , false.

Vrácená hodnota

Vrátí odkaz na lower if value < lowernebo odkaz na upper if upper < value. V opačném případě vrátí odkaz na value.

Poznámky

Chování není definováno, pokud upper je menší než lower.

copy

Přiřadí hodnoty prvků ze zdrojového rozsahu do cílového rozsahu a provede iterace přes zdrojové sekvence prvků a přiřadí je novým pozicím směrem dopředu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresuje pozici prvního prvku ve zdrojovém rozsahu.

last
Vstupní iterátor adresuje pozici, která je za posledním prvkem ve zdrojovém rozsahu.

destBeg
Výstupní iterátor adresuje pozici prvního prvku v cílovém rozsahu.

Vrácená hodnota

Výstupní iterátor adresuje pozici, která je za posledním prvkem v cílovém rozsahu, tedy adresy result iterátoru + ( - lastfirst).

Poznámky

Zdrojová oblast musí být platná a v cíli musí být dostatek místa na pro všechny prvky, které jsou kopírovány.

Vzhledem k tomu, že algoritmus kopíruje zdrojové prvky v pořadí počínaje prvním prvkem, může se cílový rozsah překrývat se zdrojovým rozsahem za předpokladu, že last umístění zdrojového rozsahu není obsaženo v cílovém rozsahu. copy lze použít k posunu prvků doleva, ale ne doprava, pokud se mezi zdrojovým a cílovým rozsahem nepřekrývají. Pokud chcete posunout doprava libovolný počet pozic, použijte copy_backward algoritmus.

Algoritmus copy upravuje pouze hodnoty odkazované iterátory a přiřazuje nové hodnoty prvkům v cílovém rozsahu. Nelze ho použít k vytvoření nových prvků a nelze je vložit přímo do prázdného kontejneru.

Příklad

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

Přiřadí hodnoty prvků ze zdrojového rozsahu do cílového rozsahu a provede iterace přes zdrojové sekvence prvků a přiřadí je novým pozicím směrem dozadu.

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

Parametry

first
Obousměrný iterátor, který adresuje umístění prvního prvku ve zdrojové oblasti.

last
Obousměrný iterátor, který adresuje umístění jedno místo za posledním prvkem ve zdrojové oblasti.

destEnd
Obousměrný iterátor, který adresuje umístění jedno místo za posledním prvkem v cílové oblasti.

Vrácená hodnota

Výstupní iterátor adresuje pozici, která je za posledním prvkem v cílovém rozsahu, tj. adresy destEnd - (last - first)iterátoru .

Poznámky

Zdrojová oblast musí být platná a v cíli musí být dostatek místa na pro všechny prvky, které jsou kopírovány.

Algoritmus copy_backward ukládá přísnější požadavky, než je tento algoritmus copy . Vstupní i výstupní iterátory musí být obousměrné.

Algoritmy copy_backward a move_backward algoritmy jsou jedinými algoritmy standardní knihovny jazyka C++ označující výstupní rozsah iterátorem odkazujícím na konec cílového rozsahu.

Vzhledem k tomu, že algoritmus kopíruje zdrojové prvky v pořadí začínajícím posledním prvkem, může se cílový rozsah překrývat se zdrojovým rozsahem za předpokladu, že first umístění zdrojového rozsahu není obsaženo v cílovém rozsahu. copy_backward lze použít k posunu prvků doprava, ale ne doleva, pokud se mezi zdrojovým a cílovým rozsahem nepřekrývají. Pokud chcete posunout libovolný počet pozic doleva, použijte copy algoritmus.

Algoritmus copy_backward upravuje pouze hodnoty odkazované iterátory a přiřazuje nové hodnoty prvkům v cílovém rozsahu. Nelze ho použít k vytvoření nových prvků a nelze je vložit přímo do prázdného kontejneru.

Příklad

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

V rozsahu prvků zkopíruje prvky, které jsou true určené pro zadanou podmínku.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje začátek rozsahu, který kontroluje podmínku.

last
Vstupní iterátor, který označuje konec oblasti.

dest
Výstupní iterátor, který označuje cíl zkopírovaných prvků.

pred
Podmínka, proti které se testuje každý prvek v rozsahu. Tuto podmínku poskytuje objekt funkce definované uživatelem. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Výstupní iterátor, který se rovná dest přírůstku jednou pro každý prvek, který splňuje podmínku. Jinými slovy, vrácená hodnota minus dest se rovná počtu zkopírovaných prvků.

Poznámky

Funkce šablony vyhodnocuje

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

jednou pro každý N v oblasti [0, last - first), pro přísně rostoucí hodnoty N začínající nejnižší hodnotou. Pokud dest a first určíte oblasti úložiště, dest nesmí být v rozsahu [ first, last ).

Příklad

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

Zkopíruje zadaný počet prvků.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje, odkud kopírovat prvky.

count
Typ celého čísla se znaménkem nebo bez znaménka určující počet prvků, které se mají zkopírovat.

dest
Výstupní iterátor, který označuje, kam kopírovat elementy.

Vrácená hodnota

Vrátí výstupní iterátor, do kterého byly prvky zkopírovány. Je to stejné jako vrácená hodnota parametru dest .

Poznámky

Funkce šablony se vyhodnocuje *(dest + N) = *(first + N)) jednou pro každou N z oblastí [0, count), pro přísně rostoucí hodnoty N začínající nejnižší hodnotou. Pak se vrátí dest + N. Pokud dest a first určíte oblasti úložiště, dest nesmí být v rozsahu [first, last).

Příklad

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

Vrátí počet prvků v rozsahu, jejichž hodnoty odpovídají zadané hodnotě.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresující pozici prvního prvku v rozsahu, který se má projít.

last
Vstupní iterátor adresující pozici za posledním prvkem v rozsahu, který se má projít.

value
Hodnota prvků, které se mají spočítat.

Vrácená hodnota

Typ rozdílu InputIterator , který spočítá počet prvků v rozsahu [first, last) s hodnotou value.

Poznámky

Použitý operator== k určení shody mezi prvkem a zadanou hodnotou musí mít vztah ekvivalence mezi jeho operandy.

Tento algoritmus je zobecněn pro počítání prvků, které splňují jakýkoli predikát funkce šablony count_if.

Příklad

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

Vrátí počet prvků v oblasti, jejichž hodnoty splňují zadanou podmínku.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last
Vstupní iterátor adresovaný pozici za posledním prvkem v oblasti, která se má prohledávat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud se má spočítat prvek. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Počet prvků, které splňují podmínku určenou predikátem.

Poznámky

Tato funkce šablony je generalizace algoritmu count, nahrazení predikátu "rovná se konkrétní hodnotě" libovolným predikátem.

Příklad

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

Porovná dva rozsahy prvek podle elementu pro rovnost nebo ekvivalenci ve smyslu určeném binárním predikátem.

Používá se std::equal při porovnávání prvků v různých typech kontejnerů (například vector a list) nebo při porovnávání různých typů elementů nebo při porovnání dílčích uspořádání kontejnerů. V opačném případě při porovnávání prvků stejného typu ve stejném typu kontejneru použijte nečlena operator== , který je k dispozici pro každý kontejner.

Přetížení duálního rozsahu použijte v kódu C++14, protože přetížení, která pro druhou oblast používají pouze jeden iterátor, nerozpozná rozdíly, pokud je druhá oblast delší než první oblast. Tato přetížení způsobí nedefinované chování, pokud je druhá oblast kratší než první oblast.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresovaný pozici prvního prvku v prvním rozsahu, který se má testovat.

last1
Vstupní iterátor adresovaný pozici za posledním prvkem v prvním rozsahu, který se má testovat.

first2
Vstupní iterátor adresovaný pozici prvního prvku ve druhém rozsahu, který se má testovat.

last2
Vstupní iterátor adresovaný pozici jednoho za posledním prvkem ve druhém rozsahu, který se má testovat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

truepokud a pouze v případě, že rozsahy jsou identické nebo ekvivalentní v binárním predikátu při porovnání prvku podle prvku; v opačném případě . false

Poznámky

Rozsah, který se má prohledávat, musí být platný; všechny iterátory musí být odvozovatelné a poslední pozice je dosažitelná od prvního zvýšením.

Pokud jsou tyto dva rozsahy stejné, je časová složitost algoritmu lineární v počtu prvků obsažených v rozsahu. V opačném případě funkce okamžitě vrátí false.

Nepotřebujete ani operator== predikát definovaný uživatelem, abyste uložili vztah ekvivalence, který je symetrický, reflexní a tranzitivní mezi jeho operandy.

Příklad

#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

Vzhledem k seřazené oblasti najde poduspořádku, ve které jsou všechny prvky ekvivalentní dané hodnotě.

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

Parametry

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

value
Hledaná hodnota v seřazené oblasti.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Dvojice předávaných iterátorů, které určují poduspořádek obsažený v prohledávaném rozsahu, ve kterém jsou všechny prvky ekvivalentní value ve smyslu definovaném binárním predikátem (buď pred nebo výchozí, menší než).

Pokud nejsou žádné prvky v oblasti ekvivalentní value, jsou iterátory ve vrácené dvojici rovny a určují bod, ve kterém value by bylo možné vložit bez narušení pořadí rozsahu.

Poznámky

První iterátor dvojice vrácené algoritmem je lower_bounda druhý iterátor je upper_bound.

Rozsah musí být seřazen podle predikátu zadaného pro equal_range. Pokud například použijete predikát větší než, musí být rozsah seřazený sestupně.

Prvky v pravděpodobně prázdném poduspořádku definované dvojicí iterátorů vrácených equal_range pomocí budou ekvivalentní hodnotě ve smyslu definovaném použitým predikátem.

Složitost algoritmu je logaritmická pro iterátory náhodného přístupu a lineární v opačném případě s počtem kroků úměrných (last - first).

Příklad

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

Každému prvku v zadaném rozsahu přiřadí stejnou novou hodnotu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresující pozici prvního prvku v rozsahu, který se má projít.

last
Dopředný iterátor adresující pozici za posledním prvkem v rozsahu, který se má projít.

value
Hodnota, která má být přiřazena prvkům v rozsahu [first, last).

Poznámky

Cílový rozsah musí být platný; všechny ukazatele musí být dereferenceable a poslední pozice je dosažitelná od prvního zvýšením. Složitost je lineární s velikostí rozsahu.

Příklad

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

Přiřadí novou hodnotu zadanému počtu prvků v oblasti začínající určitým prvkem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Výstupní iterátor adresuje pozici prvního prvku v oblasti, která má být přiřazena hodnotu value.

count
Typ celého čísla se znaménkem nebo bez znaménka určující počet prvků, které mají být přiřazeny hodnotě.

value
Hodnota, která má být přiřazena prvkům v rozsahu [first, first + count).

Vrácená hodnota

Iterátor prvku, který následuje za posledním prvkem vyplněným, pokud count> nula, jinak první prvek.

Poznámky

Cílový rozsah musí být platný; všechny ukazatele musí být dereferenceable a poslední pozice je dosažitelná od prvního zvýšením. Složitost je lineární s velikostí rozsahu.

Příklad

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

Vyhledá pozici prvního výskytu prvku v rozsahu, který má zadanou hodnotu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresovaný pozici prvního prvku v rozsahu, který se má vyhledat zadanou hodnotu.

last
Vstupní iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má vyhledat zadanou hodnotu.

value
Hodnota, kterou chcete vyhledat.

Vrácená hodnota

Vstupní iterátor adresovaný prvním výskytem zadané hodnoty v prohledávaném rozsahu. Pokud nebyl nalezen žádný prvek s ekvivalentní hodnotou, vrátí hodnotu last.

Poznámky

Použitý operator== k určení shody mezi prvkem a zadanou hodnotou musí mít vztah ekvivalence mezi jeho operandy.

Příklad kódu pomocí find(), viz find_if.

find_end

Vyhledá v rozsahu poslední dílčí sekvenci, která je shodná se zadanou sekvencí nebo která je ekvivalentní ve smyslu určeném binárním predikátem.

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

Parametry

first1
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last1
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

first2
Dopředný iterátor adresuje pozici prvního prvku v rozsahu, který chcete vyhledat.

last2
Dopředný iterátor adresuje pozici za posledním prvkem v rozsahu, který chcete vyhledat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Dopředu iterátor adresovaný pozici prvního prvku poslední dílčí sekvence v rozsahu [první1, poslední1) odpovídající zadané sekvenci [první2, poslední2).

Poznámky

Použitý operator== k určení shody mezi prvkem a zadanou hodnotou musí mít vztah ekvivalence mezi jeho operandy.

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být odvozitelné a v každé sekvenci je poslední pozice dosažitelná od prvního zvýšením.

Příklad

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

Vyhledá první výskyt libovolné z několika hodnot v cílovém rozsahu. Nebo vyhledá první výskyt některého z několika prvků, které jsou ekvivalentní ve smyslu určeném binárním predikátem pro zadanou sadu prvků.

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

Parametry

first1
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last1
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

first2
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má shodovat.

last2
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má shodovat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Forward iterator adresuje pozici prvního prvku první podsekvence, která odpovídá zadané sekvenci nebo která je ekvivalentní ve smyslu určeném binárním predikátem.

Poznámky

Použitý operator== k určení shody mezi prvkem a zadanou hodnotou musí mít vztah ekvivalence mezi jeho operandy.

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být odvozitelné a v každé sekvenci je poslední pozice dosažitelná od prvního zvýšením.

Příklad

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

Vyhledá pozici prvního výskytu prvku v rozsahu, který splňuje zadanou podmínku.

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

Parametry

first
Vstupní iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last
Vstupní iterátor adresovaný pozici za posledním prvkem v oblasti, která se má prohledávat.

pred
Uživatelem definovaný predikát objekt funkce nebo výraz lambda, který definuje podmínku, která má být splněna hledaným prvkem. Unární predikát přebírá jeden argument a vrátí true , pokud je splněn, nebo false pokud není splněn. Podpis pred musí být bool pred(const T& arg);účinně , kde T je typ, na který InputIterator lze implicitně převést při dereference. Klíčové const slovo je zobrazeno pouze pro ilustraci, že objekt funkce nebo lambda by neměl měnit argument.

Vrácená hodnota

Vstupní iterátor, který odkazuje na první prvek v rozsahu, který splňuje podmínku určenou predikátem (predikát má za truenásledek). Pokud nebyl nalezen žádný prvek pro splnění predikátu, vrátí hodnotu last.

Poznámky

Tato funkce šablony je generalizace algoritmu find, nahrazení predikátu "rovná se konkrétní hodnotě" libovolným predikátem. Pro logický opak (najděte první prvek, který nevyhovuje predikátu), viz find_if_not.

Příklad

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

Vrátí první prvek v označené oblasti, která nesplňuje podmínku.

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

Parametry

first
Vstupní iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last
Vstupní iterátor adresovaný pozici za posledním prvkem v oblasti, která se má prohledávat.

pred
Uživatelem definovaný predikát objekt funkce nebo výraz lambda, který definuje podmínku, která není splněna hledaným prvkem. Unární predikát přebírá jeden argument a vrátí true , pokud je splněn, nebo false pokud není splněn. Podpis pred musí být bool pred(const T& arg);účinně , kde T je typ, na který InputIterator lze implicitně převést při dereference. Klíčové const slovo je zobrazeno pouze pro ilustraci, že objekt funkce nebo lambda by neměl měnit argument.

Vrácená hodnota

Vstupní iterátor, který odkazuje na první prvek v oblasti, která nesplňuje podmínku určenou predikátem (predikát má za falsenásledek). Pokud všechny prvky splňují predikát (predikát je výsledkem true pro každý prvek), vrátí .last

Poznámky

Tato funkce šablony je generalizace algoritmu find, nahrazení predikátu "rovná se konkrétní hodnotě" libovolným predikátem. Pro logický opak (najděte první prvek, který vyhovuje predikátu), viz find_if.

Příklad kódu snadno přizpůsobitelný find_if_not(), viz find_if.

for_each

Na každý prvek v pořadí dopředu v rozsahu použije zadaný objekt funkce a vrátí objekt funkce.

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

Parametry

first
Vstupní iterátor adresuje pozici prvního prvku v rozsahu, na kterém se má pracovat.

last
Vstupní iterátor adresuje pozici za posledním prvkem v rozsahu, na který se pracuje.

func
Uživatelem definovaný objekt funkce, který je použit pro každý prvek v rozsahu.

Vrácená hodnota

Kopie objektu funkce po použití na všechny prvky v oblasti.

Poznámky

Algoritmus for_each je flexibilní a umožňuje úpravu jednotlivých prvků v rozsahu různými způsoby zadanými uživatelem. Šablonované funkce mohou být znovu použity v upraveném formuláři předáním různých parametrů. Uživatelem definované funkce mohou shromažďovat informace v rámci interního stavu, že se algoritmus může vrátit po zpracování všech prvků v rozsahu.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferencovatelné a v rámci sekvence musí být poslední pozice dosažitelná od prvního přírůstku.

Složitost je lineární s maximálně (last - first) porovnáními.

Příklad

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

Použije zadaný objekt funkce na zadaný počet prvků v oblasti začínající určitým prvkem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor na pozici prvního prvku v rozsahu, na kterém se má pracovat.

count
Počet prvků, na kterých se má pracovat.

func
Objekt funkce definovaný uživatelem, který se použije pro každý prvek v rozsahu [first, first + count).

Vrácená hodnota

Iterátor prvku, který následuje za posledním prvkem zpracovaným, pokud count> nula, jinak první prvek.

Poznámky

count musí být nezáporné a musí existovat alespoň count prvky v rozsahu počínaje first.

Příklad

Tento příklad definuje třídu objektu funkce. Produkční kód často používá lambda k dosažení stejného výsledku s menším kódem.

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

Přiřadí hodnoty generované objektem funkce každému prvku v rozsahu.

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

Parametry

first
Dopředný iterátor na pozici prvního prvku v oblasti, ke které mají být přiřazeny hodnoty.

last
Dopředný iterátor na pozici za posledním prvkem v oblasti, ke které mají být přiřazeny hodnoty.

gen
Objekt funkce, který je volána bez argumentů ke generování hodnot, které mají být přiřazeny ke každému prvku v oblasti.

Poznámky

Objekt funkce je vyvolán pro každý prvek v oblasti a nemusí vracet stejnou hodnotu pokaždé, když je volána. Může například číst ze souboru nebo odkazovat na místní stav a upravovat ho. Typ výsledku generátoru musí být konvertibilní na typ hodnoty iterátoru pro rozsah.

Odkazovaný rozsah musí být platný. Všechny ukazatele musí být dereferencovatelné a v rámci sekvence musí být poslední pozice dosažitelná od prvního zvýšením.

Složitost je lineární, s přesně last - first voláními generátoru.

Příklad

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

Přiřadí hodnoty vygenerované objektem funkce k zadanému počtu prvků v oblasti. Vrátí pozici za poslední přiřazenou hodnotu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Výstupní iterátor adresuje pozici prvního prvku v oblasti, ke které mají být přiřazeny hodnoty.

count
Typ celého čísla se znaménkem nebo bez znaménka určující počet prvků, které mají být přiřazeny hodnotě funkcí generátoru.

gen
Objekt funkce, který je volána bez argumentů, který se používá ke generování hodnot, které mají být přiřazeny ke každému prvku v oblasti.

Poznámky

Objekt funkce je vyvolán pro každý prvek v oblasti a nemusí vracet stejnou hodnotu pokaždé, když je volána. Může například číst ze souboru nebo odkazovat na místní stav a upravovat ho. Typ výsledku generátoru musí být konvertibilní na typ hodnoty předávaných iterátorů pro rozsah.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferencovatelné a v rámci sekvence musí být poslední pozice dosažitelná od prvního přírůstku.

Složitost je lineární, s přesně count voláním generátoru, který se vyžaduje.

Příklad

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

Ověřuje, zda jeden seřazený rozsah obsahuje všechny prvky obsažené ve druhém seřazeném rozsahu, kde kritérium pořadí nebo ekvivalence mezi prvky může být určeno binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresovaný pozici prvního prvku v první ze dvou seřazených zdrojových oblastí, který se má testovat, zda jsou všechny prvky sekundy obsaženy v první.

last1
Vstupní iterátor adresovaný pozici za posledním prvkem v první ze dvou seřazených zdrojových oblastí, který se má testovat, zda jsou všechny prvky sekundy obsaženy v prvním prvku.

first2
Vstupní iterátor adresovaný pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených zdrojových rozsahů, který se má testovat, zda jsou všechny prvky sekundy obsaženy v první.

last2
Vstupní iterátor adresovaný pozici za posledním prvkem v sekundě dvou po sobě jdoucích seřazených zdrojových oblastí, které se mají testovat, zda jsou všechny prvky sekundy obsaženy v prvním prvku.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

truepokud první seřazená oblast obsahuje všechny prvky v druhé seřazené oblasti; v opačném případě . false

Poznámky

Dalším způsobem, jak si tento test představit, je, že určuje, jestli je druhá zdrojová oblast podmnožinou prvního zdrojového rozsahu.

Seřazené zdrojové oblasti, na které odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního přírůstku.

Jako předpoklad pro použití algoritmu includesmusí být seřazené zdrojové rozsahy uspořádány se stejným pořadím, které algoritmus používá k seřazení kombinovaných rozsahů.

Rozsahy zdroje nejsou upraveny algoritmem merge.

Typy hodnot vstupních iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky. Přesněji řečeno algoritmus testuje, zda všechny prvky v první seřazené oblasti pod zadaným binárním predikátem mají ekvivalentní pořadí k prvkům ve druhé seřazené oblasti.

Složitostalgoritmuho 2 * ((last1 - first1) + (last2 - first2)) - 1

Příklad

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

Kombinuje prvky ze dvou po sobě následujících seřazených rozsahů do jednoho seřazeného rozsahu, kde kritérium pořadí může být určeno binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Obousměrný iterátor adresovaný pozici prvního prvku v první ze dvou po sobě jdoucích seřazených oblastí, které se mají zkombinovat a seřadit do jedné oblasti.

middle
Obousměrný iterátor adresovaný pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených oblastí, které se mají zkombinovat a seřadit do jedné oblasti.

last
Obousměrný iterátor adresovaný pozici za posledním prvkem ve druhé ze dvou po sobě jdoucích seřazených oblastí, které se mají zkombinovat a seřadit do jedné oblasti.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání má dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek a false jinak.

Poznámky

Seřazené po sobě jdoucí oblasti musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního přírůstku.

Seřazené po sobě jdoucí oblasti musí být uspořádány jako předběžná podmínka pro použití inplace_merge algoritmu v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů. Operace je stabilní, protože relativní pořadí prvků v rámci každého rozsahu je zachováno. Pokud jsou v obou zdrojových oblastech ekvivalentní prvky, je element prvním rozsahem před prvkem z druhého v kombinovaném rozsahu.

Složitost závisí na dostupné paměti, protože algoritmus přiděluje paměť dočasné vyrovnávací paměti. Pokud je k dispozici dostatek paměti, je nejlepší případ lineární s porovnáním(last - first) - 1; pokud není k dispozici žádná pomocná paměť, nejhorší případ je N log(N), kde N = - lastfirst.

Příklad

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

Vrátí true , pokud prvky v zadané oblasti tvoří haldu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Iterátor náhodného přístupu, který označuje začátek rozsahu, který kontroluje haldu.

last
Iterátor náhodného přístupu, který označuje konec oblasti.

pred
Podmínka, která se má testovat tak, aby se uspořádaly prvky. Predikát porovnání přebírá dva argumenty a vrátí true nebo false.

Vrácená hodnota

Vrátí true , pokud prvky v zadaném rozsahu tvoří haldu, false pokud ne.

Poznámky

První šablona funkce vrátí funkci is_heap_until(first , last) == last.

Druhá funkce šablony vrátí

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

is_heap_until

Vrátí iterátor umístěný na prvním prvku v oblasti [ first, last), který nesplňuje podmínku pořadí haldy nebo end pokud oblast tvoří haldu haldy.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Iterátor náhodného přístupu, který určuje první prvek rozsahu pro kontrolu haldy.

last
Iterátor náhodného přístupu, který určuje konec rozsahu, který kontroluje haldu.

pred
Binární predikát, který určuje striktní slabou podmínku řazení, která definuje haldu. Výchozí predikát je std::less<> , když pred není zadaný.

Vrácená hodnota

Vrátí last , pokud zadaná oblast tvoří haldu nebo obsahuje jeden nebo méně prvků. V opačném případě vrátí iterátor pro první nalezený prvek, který nesplňuje podmínku haldy.

Poznámky

První funkce šablony vrátí poslední iterátor next v místě, kde [first, last) [first, next) je halda seřazená objektem std::less<>funkce . Pokud je vzdálenost last - first menší než 2, vrátí lastfunkce .

Druhá funkce šablony se chová stejně jako první, s tím rozdílem, že místo podmínky řazení haldy používá predikát pred std::less<> .

is_partitioned

Vrátí true , pokud všechny prvky v daném rozsahu, které testuje true podmínku, přicházejí před všechny prvky, které testuje false.

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

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje, kde oblast začíná kontrolovat podmínku.

last
Vstupní iterátor, který označuje konec oblasti.

pred
Podmínka, pro která se má testovat. Tento test poskytuje uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna hledaným prvkem. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Vrátí true , když všechny prvky v daném rozsahu, které testuje true podmínku, přicházejí před všechny prvky, které testuje false, a v opačném případě vrátí false.

Poznámky

Funkce šablony vrátí true pouze v případě, že jsou všechny prvky v [first, last) oddílu pred; to znamená, že všechny prvky X , ve [first, last) kterých pred (X) je pravda, nastane před všemi prvky Y , pro které pred (Y) je false.

is_permutation

Vrátí true , pokud obě oblasti obsahují stejné prvky, zda jsou prvky ve stejném pořadí. Přetížení duálního rozsahu použijte v kódu C++14, protože přetížení, která pro druhou oblast používají pouze jeden iterátor, nerozpozná rozdíly, pokud je druhá oblast delší než první oblast. Tato přetížení způsobí nedefinované chování, pokud je druhá oblast kratší než první oblast.

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

Parametry

first1
Dopředný iterátor, který odkazuje na první prvek rozsahu.

last1
Dopředný iterátor, který odkazuje na poslední prvek rozsahu.

first2
Dopředný iterátor, který odkazuje na první prvek druhého rozsahu, který se používá k porovnání.

last2
Forward iterator, který odkazuje na jeden za poslední prvek druhého rozsahu, který se používá k porovnání.

pred
Predikát, který testuje ekvivalenci a vrací boolhodnotu .

Vrácená hodnota

truepokud lze rozsahy přeuspořádat tak, aby byly identické podle srovnávacího predikátu; v opačném případě . false

Poznámky

is_permutation má v nejhorším případě kvadratickou složitost.

První funkce šablony předpokládá, že v rozsahu začíná tolik prvků, kolik first2 je v rozsahu určeném [first1, last1). Pokud je ve druhém rozsahu více prvků, budou ignorovány; pokud je méně, dojde k nedefinované chování. Třetí funkce šablony (C++14 a novější) tento předpoklad neuvádí. Obě vrátí true pouze v případě, že pro každý prvek X v rozsahu určeném [first1, last1) existuje tolik prvků Y ve stejné oblasti, pro které X == Y existuje rozsah začínající na first2 nebo [first2, last2). operator== Tady musí provést párové porovnání mezi jeho operandy.

Funkce druhé a čtvrté šablony se chovají stejně, s tím rozdílem, že je nahradí operator==(X, Y) .Pred(X, Y) Aby se predikát chovat správně, musí být symetrický, reflexní a tranzitivní.

Příklad

Následující příklad ukazuje, jak používat 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

Vrátí true , pokud jsou prvky v zadaném rozsahu seřazené.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor, který označuje, kde začíná rozsah, který se má zkontrolovat.

last
Dopředný iterátor, který označuje konec rozsahu.

pred
Podmínka, která se má testovat, aby určila pořadí mezi dvěma prvky. Predikát porovnání přebírá dva argumenty a vrátí true nebo false. Tento predikát provádí stejnou úlohu jako operator<.

Poznámky

První šablona funkce vrátí funkci is_sorted_until( first, last ) == last. Funkce operator< provede porovnání pořadí.

Druhá funkce šablony vrátí is_sorted_until( first, last , pred ) == last. Predikát pred provádí porovnání pořadí.

is_sorted_until

Vrátí hodnotu nastavenou ForwardIterator na poslední prvek, který je seřazený z zadaného rozsahu.

Druhá verze umožňuje poskytnout objekt funkce porovnání, který vrátí true , když jsou dva dané prvky seřazené a false jinak.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor, který označuje, kde se má oblast zkontrolovat.

last
Dopředný iterátor, který označuje konec rozsahu.

pred
Podmínka, která se má testovat, aby určila pořadí mezi dvěma prvky. Predikát porovnání přebírá dva argumenty a vrátí true nebo false.

Vrácená hodnota

ForwardIterator Vrátí sadu na poslední prvek v seřazeném pořadí. Seřazená sekvence začíná od first.

Poznámky

První funkce šablony vrátí poslední iterátor next [first, last] tak, aby [first, next) byla seřazená sekvence seřazená podle operator<. Pokud distance() je menší než 2, vrátí lastfunkce hodnotu .

Druhá funkce šablony se chová stejně, s tím rozdílempred(X, Y), že nahrazuje operator<(X, Y) .

iter_swap

Vymění dvě hodnoty odkazované dvojicí zadaných iterátorů.

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

Parametry

left
Jeden z předávaných iterátorů, jejichž hodnota se má vyměnit.

right
Druhý z iterátorů předávání, jejichž hodnota se má vyměnit.

Poznámky

swap měla by být použita přednost před iter_swap, která byla součástí standardu C++ pro zpětnou kompatibilitu. Pokud Fit1 a Fit2 jsou vpřed iterátory, pak iter_swap( Fit1, Fit2 )je ekvivalentní swap( *Fit1, *Fit2 ).

Typy hodnot vstupních iterátorů pro předávání musí mít stejnou hodnotu.

Příklad

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

Porovná prvek po prvku mezi dvěma sekvencemi k určení, která z nich je menší.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresuje pozici prvního prvku v prvním rozsahu, který se má porovnat.

last1
Vstupní iterátor adresuje pozici za posledním prvkem v prvním rozsahu, který se má porovnat.

first2
Vstupní iterátor adresuje pozici prvního prvku ve druhém rozsahu, který se má porovnat.

last2
Vstupní iterátor adresuje pozici za posledním prvkem ve druhém rozsahu, který se má porovnat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

true pokud je první oblast lexikálně menší než druhá oblast; jinak false.

Poznámky

Lexikografické porovnání mezi sekvencemi je porovnává prvek podle elementu, dokud:

• Najde dva odpovídající prvky, které jsou nerovné, a výsledek jejich porovnání se bere jako výsledek porovnání mezi sekvencemi.

• Nebyly nalezeny žádné nerovnosti, ale jedna sekvence má více prvků než druhá a kratší sekvence se považuje za menší než delší posloupnost.

• Nebyly nalezeny žádné nerovnosti a sekvence mají stejný počet prvků, takže sekvence jsou stejné a výsledek porovnání je false.

Příklad

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

Vyhledá pozici prvního prvku v seřazené oblasti, která má hodnotu větší nebo ekvivalentní zadané hodnotě. Kritérium řazení může být určeno binárním predikátem.

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

Parametry

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

value
Hodnota, jejíž první pozice nebo možná první pozice se hledá v seřazené oblasti.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Dopředný iterátor na pozici prvního prvku v seřazené oblasti s hodnotou, která je větší nebo ekvivalentní zadané hodnotě. Ekvivalence může být určena binárním predikátem.

Poznámky

Seřazený zdrojový rozsah, na který odkazuje, musí být platný; všechny iterátory musí být odvozovatelné a v pořadí musí být poslední pozice dosažitelná od prvního zvýšením.

Seřazený rozsah je předběžnou podmínkou použití lower_bound a kde je řazení stejné jako u binárního predikátu.

Rozsah není upraven algoritmem lower_bound.

Typy hodnot předávaných iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky.

Složitost algoritmu je logaritmická pro iterátory náhodného přístupu a lineární v opačném případě s počtem kroků úměrných (last - first).

Příklad

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

Převede prvky ze zadaného rozsahu do haldy, ve které je první prvek největší a pro kterou může být kritérium řazení určeno binárním predikátem.

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

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

Parametry

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v rozsahu, který se má převést na haldu.

last
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má převést na haldu.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Haldy mají dvě vlastnosti:

• První prvek je vždy největší.

• Prvky mohou být přidány nebo odebrány v logaritmickém čase.

Haldy jsou ideální způsob, jak implementovat prioritní fronty a používají se při implementaci adaptéru kontejneru standardní knihovny C++ priority_queue třídy.

Složitost je lineární a vyžaduje 3 * (last - first) porovnání.

Příklad

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

Porovná dva objekty a vrátí větší z nich, kde kritérium pořadí může být určeno binárním predikátem.

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

Parametry

left
První ze dvou objektů, které se porovnávají.

right
Druhý ze dvou objektů, které se porovnávají.

pred
Binární predikát použitý k porovnání těchto dvou objektů.

inlist
Seznam inicializátoru obsahující objekty, které se mají porovnat.

Vrácená hodnota

Větší ze dvou objektů, pokud ani jeden není větší; v takovém případě vrátí první ze dvou objektů. initializer_list Při zadání vrátí největší z objektů v seznamu.

Poznámky

Algoritmus max je neobvyklý v tom, že objekty předané jako parametry. Většinaalgoritmch Pokud potřebujete funkci, která pracuje s rozsahem prvků, použijte max_element místo toho. Visual Studio 2017 umožňuje constexpr přetížení, která přebírají initializer_list.

Příklad

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

Vyhledá první výskyt největšího prvku v zadaném rozsahu, kde kritérium pořadí může být určeno binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má vyhledat největší prvek.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má vyhledat největší prvek.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání má dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek a false jinak.

Vrácená hodnota

Dopředný iterátor adresovaný pozici prvního výskytu největšího prvku v prohledáné oblasti.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferencovatelné a v každé sekvenci je poslední pozice dosažitelná od prvního zvýšením.

Složitost je lineární: (last - first) - 1 porovnání jsou vyžadována pro neprázdný rozsah.

Příklad

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

Kombinuje všechny prvky ze dvou seřazených zdrojových oblastí do jednoho seřazeného cílového rozsahu, kde kritérium řazení může být určeno binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresovaný pozici prvního prvku v první ze dvou seřazených zdrojových oblastí, které se mají zkombinovat a řadit do jedné oblasti.

last1
Vstupní iterátor adresovaný pozici za posledním prvkem v první ze dvou seřazených zdrojových oblastí, které se mají zkombinovat a seřadit do jedné oblasti.

first2
Vstupní iterátor adresovaný pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených zdrojových oblastí, které se mají zkombinovat a seřadit do jedné oblasti.

last2
Vstupní iterátor adresovaný pozici za posledním prvkem v sekundě dvou po sobě jdoucích seřazených zdrojových rozsahů, které se mají zkombinovat a seřadit do jedné oblasti.

result
Výstupní iterátor adresovaný pozici prvního prvku v cílovém rozsahu, kde se obě zdrojové oblasti mají zkombinovat do jedné seřazené oblasti.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání má dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek, a false jinak.

Vrácená hodnota

Výstupní iterátor adresovaný pozici za posledním prvkem v seřazené cílové oblasti.

Poznámky

Seřazené zdrojové oblasti, na které odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením.

Cílový rozsah by se neměl překrývat ani jeden ze zdrojových rozsahů a měl by být dostatečně velký, aby obsahoval cílový rozsah.

Seřazené zdrojové rozsahy musí být uspořádány jako předběžná podmínka pro použití merge algoritmu v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů.

Operace je stabilní, protože relativní pořadí prvků v jednotlivých oblastech je zachováno v cílovém rozsahu. Rozsahy zdroje nejsou upraveny algoritmem merge.

Typy hodnot vstupních iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky. Pokud jsou v obou zdrojových oblastech ekvivalentní prvky, prvky v první oblasti před prvky z druhého zdrojového rozsahu v cílovém rozsahu.

Složitost algoritmu je lineární s většinou (last1 - first1) - (last2 - first2) - 1 porovnání.

Třída list poskytuje členovou funkci merge pro sloučení prvků dvou seznamů.

Příklad

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

Porovná dva objekty a vrátí menší z nich, kde kritérium pořadí může být určeno binárním predikátem.

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

Parametry

left
První ze dvou objektů, které se porovnávají.

right
Druhý ze dvou objektů, které se porovnávají.

pred
Binární predikát použitý k porovnání těchto dvou objektů.

inlist
Ten initializer_list obsahuje členy, které se mají porovnat.

Vrácená hodnota

Menší ze dvou objektů, pokud není ani menší; v takovém případě vrátí první ze dvou objektů. initializer_list Při zadání vrátí nejméně z objektů v seznamu.

Poznámky

Algoritmus min je neobvyklý v tom, že objekty předané jako parametry. Většinaalgoritmch Pokud potřebujete funkci, která používá rozsah prvků, použijte min_element. constexpr byla povolena pro initializer_list přetížení v sadě Visual Studio 2017.

Příklad

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

Vyhledá první výskyt nejmenšího prvku v zadaném rozsahu, kde kritérium pořadí může být určeno binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má vyhledat nejmenší prvek.

last
Dopředný iterátor adresovaný pozici po posledním prvku v rozsahu, který se má vyhledat nejmenší prvek.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání má dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek, a false jinak.

Vrácená hodnota

Dopředný iterátor adresovaný pozici prvního výskytu nejmenšího prvku v prohledáné oblasti.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferencovatelné a v každé sekvenci je poslední pozice dosažitelná od prvního zvýšením.

Složitost je lineární: (last - first) - 1 porovnání jsou vyžadována pro neprázdný rozsah.

Příklad

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

Provede práci provedenou jedním voláním min_element a max_element v jednom volání.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor, který označuje začátek rozsahu.

last
Dopředný iterátor, který označuje konec rozsahu.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání má dva argumenty a měl by se vrátit true , když je první menší než druhý, a false jinak.

Vrácená hodnota

Návraty

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

Poznámky

První funkce šablony vrátí

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

Druhá funkce šablony se chová stejně, s tím rozdílempred(X, Y), že nahrazuje operator<(X, Y) .

Pokud je sekvence neprázdná, funkce provede většinu 3 * (last - first - 1) / 2 porovnání.

minmax

Porovná dva vstupní parametry a vrátí je jako dvojici v pořadí od menšího po větší.

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

Parametry

left
První ze dvou objektů, které se porovnávají.

right
Druhý ze dvou objektů, které se porovnávají.

pred
Binární predikát použitý k porovnání těchto dvou objektů.

inlist
Ten initializer_list obsahuje členy, které se mají porovnat.

Poznámky

První funkce šablony vrátí pair<const Type&, const Type&>( right, left ) , pokud right je menší než left. V opačném případě se vrátí pair<const Type&, const Type&>( left, right ).

Druhá členská funkce vrátí dvojici, ve které je první prvek menší a druhý je při porovnání predikátem predvětší .

Zbývající funkce šablony se chovají stejně, s tím rozdíleminlist, že nahrazují left parametry right .

Funkce provádí přesně jedno porovnání.

mismatch

Porovná dva oblasti prvek podle elementu a vyhledá první pozici, kde dochází k rozdílu.

Přetížení duálního rozsahu použijte v kódu C++14, protože přetížení, která pro druhou oblast používají pouze jeden iterátor, nerozpozná rozdíly, pokud je druhá oblast delší než první oblast. Tato přetížení způsobí nedefinované chování, pokud je druhá oblast kratší než první oblast.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresovaný pozici prvního prvku v prvním rozsahu, který se má testovat.

last1
Vstupní iterátor adresovaný pozici za posledním prvkem v prvním rozsahu, který se má testovat.

first2
Vstupní iterátor adresovaný pozici prvního prvku ve druhém rozsahu, který se má testovat.

last2
Vstupní iterátor adresovaný pozici jednoho za posledním prvkem ve druhém rozsahu, který se má testovat.

pred
Uživatelem definovaný predikát objekt funkce, který porovnává aktuální prvky v jednotlivých rozsahech a určuje, jestli jsou ekvivalentní. Vrátí true se, když jste spokojení a false kdy nejsou spokojení.

Vrácená hodnota

Vrátí dvojici iterátorů adresujících pozice neshody ve dvou oblastech. Iterátor první komponenty odkazuje na pozici v prvním rozsahu. Druhý iterátor komponenty odkazuje na pozici ve druhém rozsahu. Pokud mezi prvky ve srovnání s rozsahy není žádný rozdíl nebo pokud binární predikát ve druhé verzi jsou splněny všemi dvojicemi prvků ze dvou oblastí, pak první iterátor komponenty odkazuje na pozici za posledním prvkem v první oblasti a druhý komponentní iterátor odkazuje na pozici jedna za posledním prvkem testovaným v druhém rozsahu.

Poznámky

První funkce šablony předpokládá, že v rozsahu začíná na začátku 2 tolik prvků, kolik je v rozsahu určeném [první1, poslední1). Pokud je ve druhém rozsahu více, budou ignorovány; pokud je méně, výsledkem bude nedefinované chování.

Rozsah, který se má prohledávat, musí být platný; všechny iterátory musí být odvozovatelné a poslední pozice je dosažitelná od prvního zvýšením.

Časová složitost algoritmu je lineární v počtu prvků obsažených v kratším rozsahu.

Predikát definovaný uživatelem není nutný k uložení vztahu ekvivalence, který je symetrický, reflexní a tranzitivní mezi jeho operandy.

Příklad

Následující příklad ukazuje, jak použít neshodu. Přetížení C++03 je zobrazeno pouze za účelem předvedení toho, jak může způsobit neočekávaný výsledek.

#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

Přesune prvky přidružené k určenému rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje, kam se má oblast prvků přesunout.

last
Vstupní iterátor, který označuje konec oblasti prvků, které se mají přesunout.

dest
Výstupní iterátor, který má obsahovat přesunuté prvky.

Poznámky

Funkce šablony se vyhodnocuje *(dest + N) = move(*(first + N)) jednou pro každou N z oblastí [0, last - first), pro přísně rostoucí hodnoty N začínající nejnižší hodnotou. Pak se vrátí dest + N. Pokud dest a first určíte oblasti úložiště, dest nesmí být v rozsahu [first, last).

move_backward

Přesune prvky jednoho iterátoru do druhého. Pohyb začíná posledním prvkem v daném rozsahu a končí prvním prvkem v daném rozsahu.

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

Parametry

first
Iterátor, který označuje začátek rozsahu pro přesun prvků.

last
Iterátor, který označuje konec oblasti, ze které se mají přesunout prvky. Tento prvek se nepřesune.

destEnd
Obousměrný iterátor, který adresuje umístění jedno místo za posledním prvkem v cílové oblasti.

Poznámky

Funkce šablony se vyhodnocuje *(destEnd - N - 1) = move(*(last - N - 1)) jednou pro každou N z oblastí [0, last - first), pro přísně rostoucí hodnoty N začínající nejnižší hodnotou. Pak se vrátí destEnd - (last - first). Pokud destEnd a first určíte oblasti úložiště, destEnd nesmí být v rozsahu [first, last).

move a move_backward jsou funkčně ekvivalentní použití copy a copy_backward s iterátorem přesunutí.

next_permutation

Změní pořadí prvků v oblasti tak, aby původní řazení bylo nahrazeno lexikálně další permutací, pokud existuje. Význam lexikálně dalšího může být určen binárním predikátem.

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

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

Parametry

first
Obousměrný iterátor ukazující na pozici prvního prvku v rozsahu, který má být permutován.

last
Obousměrný iterátor ukazující na pozici za posledním prvkem v oblasti, která se má permutovat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

true pokud existuje lexikicky další permutace a nahradil původní pořadí rozsahu; jinak false, v takovém případě pořadí je transformováno na lexicicky nejmenší permutaci.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Výchozí binární predikát je menší než a prvky v rozsahu musí být menší než srovnatelné, aby bylo zajištěno, že je další permutace dobře definovaná.

Složitost je lineární s většinou (last - first) / 2 prohození.

Příklad

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

Rozdělí oblast prvků, správně lokaluje n. prvek sekvence v oblasti, která splňuje tato kritéria: Všechny prvky před ním jsou menší nebo rovné a všechny prvky, které následují, jsou větší nebo rovno.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v rozsahu, který se má rozdělit.

nth
Iterátor náhodného přístupu adresovaný pozici prvku, který se má správně uspořádat na hranici oddílu.

last
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má rozdělit.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Predikát porovnání přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Algoritmus nth_element nezaručuje, že prvky v poduspořádkách jsou seřazené na obou stranách n. elementu. Díky tomu je méně záruk než partial_sort, které objednává prvky v rozsahu pod vybraným prvkem a mohou být použity jako rychlejší alternativu k partial_sort tomu, když řazení nižšího rozsahu není vyžadováno.

Prvky jsou ekvivalentní, ale nemusí se nutně rovnat, pokud ani jeden není menší než druhý.

Průměr složitosti řazení je lineární s ohledem na last - first.

Příklad

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

Vrátí true , když podmínka není nikdy přítomna mezi prvky v daném rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje, kde začít kontrolovat rozsah prvků pro podmínku.

last
Vstupní iterátor, který označuje konec oblasti prvků.

pred
Podmínka, pro která se má testovat. Tento test poskytuje uživatelem definovaný predikát objekt funkce, který definuje podmínku. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Vrátí true , pokud podmínka není v zadaném rozsahu zjištěna alespoň jednou a false pokud je podmínka zjištěna.

Poznámky

Funkce šablony vrátí true pouze v případě, že u některých N v oblasti [0, last - first)je predikát pred(*(first + N)) vždy false.

partial_sort

Uspořádá zadaný počet menších prvků v rozsahu do nedecendujícího pořadí. Binární predikát může zadat kritérium řazení.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.

sortEnd
Iterátor náhodného přístupu adresovaný pozici za posledním prvkem v poduspořádku, který se má seřadit.

last
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má částečně řadit.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Prvky jsou ekvivalentní, ale nemusí se nutně rovnat, pokud ani jeden není menší než druhý. Algoritmus sort není stabilní a nezaručuje zachování relativního pořadí ekvivalentních prvků. Algoritmus stable_sort zachová toto původní řazení.

Průměrná částečná složitost řazení je protokol O((last- first) (sortEnd- first)).

Příklad

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

Zkopíruje prvky ze zdrojového rozsahu do cílového rozsahu, kde zdrojové prvky jsou seřazeny buď podle binárního predikátu „menší než“ nebo jiného určeného binárního predikátu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresuje pozici prvního prvku ve zdrojovém rozsahu.

last1
Vstupní iterátor adresuje pozici za posledním prvkem ve zdrojovém rozsahu.

first2
Iterátor náhodného přístupu adresuje pozici prvního prvku v seřazené cílové oblasti.

last2
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v seřazené cílové oblasti.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Iterátor náhodného přístupu adresuje prvek v cílovém rozsahu o jednu pozici za posledním prvkem vloženým ze zdrojového rozsahu.

Poznámky

Zdrojové a cílové oblasti se nesmí překrývat a musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením.

Binární predikát musí poskytovat striktní slabé řazení, aby prvky, které nejsou ekvivalentní, byly seřazeny, ale prvky, které jsou ekvivalentní, nejsou. Dva prvky jsou ekvivalentní pod méně než, ale nemusí se nutně rovnat, pokud ani jeden není menší než druhý.

Příklad

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

Klasifikuje prvky v oblasti do dvou oddělených sad, přičemž tyto prvky splňují unární predikát před těmi, které jej nesplňují.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Obousměrný iterátor adresovaný pozici prvního prvku v rozsahu, který se má rozdělit.

last
Obousměrný iterátor adresovaný pozici po posledním prvku v rozsahu, který se má rozdělit.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud má být prvek klasifikován. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

Obousměrný iterátor adresuje pozici prvního prvku v rozsahu tak, aby nevyhovuje predikátové podmínce.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Prvky a a b jsou ekvivalentní, ale nemusí se nutně rovnat, pokud je false pred( a, b ) a pred( b, a ) je false, kde pred je predikát zadaný parametrem. Algoritmus partition není stabilní a nezaručuje zachování relativního pořadí ekvivalentních prvků. Algoritmus stable_partition zachová toto původní řazení.

Složitost je lineární: existují (last - first) aplikace pred a většina (last - first)/2 prohození.

Příklad

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

Zkopíruje prvky, pro které je true podmínka do jednoho cíle a pro které je false podmínka na jinou. Prvky musí pocházet ze zadaného rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor, který označuje začátek oblasti, která kontroluje podmínku.

last
Vstupní iterátor, který označuje konec oblasti.

dest1
Výstupní iterátor použitý ke kopírování prvků, které vrací hodnotu true pro podmínku testovanou pomocí pred.

dest2
Výstupní iterátor použitý ke kopírování prvků, které vrací hodnotu false pro podmínku testovanou pomocí pred.

pred
Podmínka, pro která se má testovat. Test poskytuje uživatelem definovaný predikát objekt funkce, který definuje podmínku, která se má testovat. Unární predikát přebírá jeden argument a vrátí true nebo false.

Poznámky

Funkce šablony zkopíruje každý prvek [first,last) X, pokud pred(X) *dest1++ je true, nebo do*dest2++, pokud ne. pair<OutputIterator1, OutputIterator2>(dest1, dest2)Vrátí .

partition_point

Vrátí první prvek v daném rozsahu, který nesplňuje podmínku. Prvky jsou seřazené tak, aby ty, které splňují podmínku, přišly před ty, které nejsou.

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

Parametry

first
A ForwardIterator označující začátek rozsahu, který kontroluje podmínku.

last
A ForwardIterator označující konec rozsahu.

pred
Podmínka, pro která se má testovat. Test poskytuje uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna hledaným prvkem. Unární predikát přebírá jeden argument a vrátí true nebo false.

Vrácená hodnota

ForwardIterator Vrátí hodnotu, která odkazuje na první prvek, který nesplňuje podmínku testovanou pomocí pred, nebo vrátílast, pokud se nenajde.

Poznámky

Funkce šablony najde první iterátor it , ve [first, last) kterém pred(*it) je false. Pořadí musí být seřazeno podle pred.

pop_heap

Odstraní největší prvek z přední části haldy až do předposlední pozice v rozsahu a ze zbývajících prvků vytvoří novou haldu.

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

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

Parametry

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v haldě.

last
Iterátor náhodného přístupu adresuje pozici za posledním prvkem haldy.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Algoritmus pop_heap je inverzní k operaci prováděné algoritmem push_heap, ve kterém je prvek na další pozici rozsahu přidán do haldy skládající se z předchozích prvků v oblasti, v případě, že je prvek přidaný do haldy větší než kterýkoli z prvků již v haldě.

Haldy mají dvě vlastnosti:

• První prvek je vždy největší.

• Prvky mohou být přidány nebo odebrány v logaritmickém čase.

Haldy jsou ideální způsob, jak implementovat prioritní fronty a používají se při implementaci adaptéru kontejneru standardní knihovny C++ priority_queue třídy.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Oblast s výjimkou nově přidaného prvku na konci musí být haldou.

Složitost je logaritmická a vyžaduje většinu log (last - first) porovnání.

Příklad

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

Změní pořadí prvků v oblasti tak, aby původní řazení bylo nahrazeno lexikálně předchozím větší permutací, pokud existuje. Binární predikát může určit smysl lexikálně předchozího.

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

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

Parametry

first
Obousměrný iterátor ukazující na pozici prvního prvku v rozsahu, který má být permutován.

last
Obousměrný iterátor ukazující na pozici za posledním prvkem v oblasti, která se má permutovat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

true pokud lexikálně předchozí permutaci existuje a nahradil původní pořadí rozsahu; jinak false, v takovém případě pořadí je transformováno na lexicicky největší permutaci.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Výchozí binární predikát je menší než a prvky v rozsahu musí být menší než srovnatelné, aby bylo zajištěno, že předchozí permutace je dobře definovaná.

Složitost je lineární, s maximálně (last - first)/2 prohozeními.

Příklad

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

Přidá prvek, který je na konci rozsahu, do stávající haldy, která zahrnuje předchozí prvky daného rozsahu.

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

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

Parametry

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v haldě.

last
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má převést na haldu.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Prvek musí být nejprve nasdílený zpět na konec existující haldy a pak se algoritmus použije k přidání tohoto prvku do existující haldy.

Haldy mají dvě vlastnosti:

• První prvek je vždy největší.

• Prvky mohou být přidány nebo odebrány v logaritmickém čase.

Haldy jsou ideální způsob, jak implementovat prioritní fronty a používají se při implementaci adaptéru kontejneru standardní knihovny C++ priority_queue třídy.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Oblast s výjimkou nově přidaného prvku na konci musí být haldou.

Složitost je logaritmická a vyžaduje většinu log(last - first) porovnání.

Příklad

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

Funkce std::random_shuffle() je zastaralá, nahrazena .std::shuffle Příklad kódu a další informace najdete <random> v příspěvku Stack Overflow o tom, proč jsou std::random_shuffle metody zastaralé v jazyce C++14?.

remove

Eliminuje zadanou hodnotu z daného rozsahu bez narušení pořadí zbývajících prvků. Vrátí konec nového rozsahu bez zadané hodnoty.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, ze kterého se odebírají prvky.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v oblasti, ze které se odebírají prvky.

value
Hodnota, která má být odebrána z rozsahu.

Vrácená hodnota

Dopředný iterátor adresovaný novou koncovou pozici upraveného rozsahu, jeden za posledním prvkem zbytkové sekvence bez zadané hodnoty.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Pořadí prvků, které nebyly odebrány, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti.

Třída list má efektivnější verzi removečlenské funkce , která také znovu propoje ukazatele.

Příklad

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

Zkopíruje prvky ze zdrojového rozsahu do cílového rozsahu s tím rozdílem, že prvky zadané hodnoty se nekopírují, aniž by to rušilo pořadí zbývajících prvků. Vrátí konec nového cílového rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresovaný pozici prvního prvku v rozsahu, ze kterého se odebírají prvky.

last
Vstupní iterátor adresovaný pozici za posledním prvkem v oblasti, ze které se odebírají prvky.

result
Výstupní iterátor adresovaný pozici prvního prvku v cílovém rozsahu, do kterého se odebírají elementy.

value
Hodnota, která má být odebrána z rozsahu.

Vrácená hodnota

Dopředný iterátor adresovaný novou koncovou pozici cílového rozsahu, jeden za posledním prvkem kopie zbytkové sekvence bez zadané hodnoty.

Poznámky

Zdrojové a cílové rozsahy, na které odkazuje, musí být platné; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

V cílovém rozsahu musí být dostatek místa, aby obsahoval zbytek prvků, které budou zkopírovány po odebrání prvků zadané hodnoty.

Pořadí prvků, které nebyly odebrány, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti a maximálně (last - first) přiřazení.

Příklad

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

Zkopíruje prvky ze zdrojového rozsahu do cílového rozsahu s výjimkou prvků, které splňují predikát. Prvky se zkopírují bez narušení pořadí zbývajících prvků. Vrátí konec nového cílového rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresovaný pozici prvního prvku v rozsahu, ze kterého se odebírají prvky.

last
Vstupní iterátor adresovaný pozici za posledním prvkem v oblasti, ze které se odebírají prvky.

result
Výstupní iterátor adresovaný pozici prvního prvku v cílovém rozsahu, do kterého se odebírají elementy.

pred
Unární predikát, který musí být splněn, je hodnota prvku je nahrazena.

Vrácená hodnota

Dopředný iterátor adresující novou koncovou pozici cílového rozsahu, jeden za posledním prvkem zbytkové sekvence bez prvků splňujících predikát.

Poznámky

Odkazovaný zdrojový rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

V cílovém rozsahu musí být dostatek místa, aby obsahoval zbytek prvků, které budou zkopírovány po odebrání prvků zadané hodnoty.

Pořadí prvků, které nebyly odebrány, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti a maximálně (last - first) přiřazení.

Informace o chování těchto funkcí najdete v tématu Kontrola iterátorů.

Příklad

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

Eliminuje prvky, které splňují predikát z daného rozsahu bez narušení pořadí zbývajících prvků. Vrátí konec nového rozsahu bez zadané hodnoty.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor ukazující na pozici prvního prvku v oblasti, ze které se odebírají prvky.

last
Dopředný iterátor ukazující na pozici za posledním prvkem v oblasti, ze které se odebírají prvky.

pred
Unární predikát, který musí být splněn, je hodnota prvku je nahrazena.

Vrácená hodnota

Dopředný iterátor adresovaný novou koncovou pozici upraveného rozsahu, jeden za posledním prvkem zbytkové sekvence bez zadané hodnoty.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Pořadí prvků, které nebyly odebrány, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti.

Seznam má efektivnější verzi členské funkce odebrání, která znovu propoje ukazatele.

Příklad

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

Zkontroluje každý prvek v rozsahu a nahradí jej, pokud odpovídá zadané hodnotě.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor ukazující na pozici prvního prvku v oblasti, ze které jsou prvky nahrazeny.

last
Dopředný iterátor ukazující na pozici za posledním prvkem v oblasti, ze které jsou prvky nahrazeny.

oldVal
Stará hodnota prvků, které se nahrazují.

newVal
Nová hodnota přiřazená prvkům se starou hodnotou.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Pořadí prvků, které nejsou nahrazeny, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti a maximálně (last - first) přiřazení nových hodnot.

Příklad

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

Zkontroluje každý prvek ve zdrojovém rozsahu a nahradí jej, pokud při kopírování výsledku do nového cílového rozsahu odpovídá zadané hodnotě.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor odkazující na pozici prvního prvku v oblasti, ze které se prvky nahrazují.

last
Vstupní iterátor ukazující na pozici po posledním prvku v oblasti, ze které jsou prvky nahrazeny.

result
Výstupní iterátor odkazující na první prvek v cílovém rozsahu, do kterého se kopíruje změněná posloupnost prvků.

oldVal
Stará hodnota prvků, které se nahrazují.

newVal
Nová hodnota přiřazená prvkům se starou hodnotou.

Vrácená hodnota

Výstupní iterátor odkazující na pozici za posledním prvkem v cílovém rozsahu, do které se zkopírovala změněná posloupnost prvků.

Poznámky

Zdrojové a cílové oblasti, na které odkazuje, se nesmí překrývat a musí být platné: všechny ukazatele musí být dereferencovatelné a v rámci sekvencí, na které je poslední pozice dosažitelná od prvního zvýšením.

Pořadí prvků, které nejsou nahrazeny, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti a maximálně (last - first) přiřazení nových hodnot.

Příklad

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

Kvůli random_shuffle() volání v předchozím kódu se může výstup lišit.

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

Zkontroluje každý prvek ve zdrojovém rozsahu a nahradí jej, pokud při kopírování výsledku do nového cílového rozsahu splňuje zadaný predikát.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Vstupní iterátor odkazující na pozici prvního prvku v oblasti, ze které se prvky nahrazují.

last
Vstupní iterátor ukazující na pozici po posledním prvku v oblasti, ze které jsou prvky nahrazeny.

result
Výstupní iterátor odkazující na pozici prvního prvku v cílovém rozsahu, do kterého se elementy kopírují.

pred
Unární predikát, který musí být splněn, je hodnota prvku je nahrazena.

value
Nová hodnota přiřazená prvkům, jejichž stará hodnota splňuje predikát.

Vrácená hodnota

Výstupní iterátor odkazující na pozici za posledním prvkem v cílovém rozsahu, do které se zkopírovala změněná posloupnost prvků.

Poznámky

Zdrojové a cílové oblasti, na které odkazuje, se nesmí překrývat a musí být platné: všechny ukazatele musí být dereferencovatelné a v rámci sekvencí, na které je poslední pozice dosažitelná od prvního zvýšením.

Pořadí prvků, které nejsou nahrazeny, zůstává stabilní.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti a maximálně (last - first) přiřazení nových hodnot.

Příklad

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

Zkontroluje každý prvek v rozsahu a nahradí jej, pokud splňuje zadaný predikát.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor ukazující na pozici prvního prvku v oblasti, ze které jsou prvky nahrazeny.

last
Iterátor ukazující na pozici po posledním prvku v oblasti, ze které se prvky nahrazují.

pred
Unární predikát, který musí být splněn, je hodnota prvku je nahrazena.

value
Nová hodnota přiřazená prvkům, jejichž stará hodnota splňuje predikát.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Pořadí prvků, které nejsou nahrazeny, zůstává stabilní.

Algoritmus replace_if je generalizace algoritmu replace, která umožňuje zadat jakýkoli predikát, nikoli rovnost se zadanou konstantní hodnotou.

Použitý operator== k určení rovnosti mezi prvky musí mít vztah ekvivalence mezi jeho operandy.

Složitost je lineární. Provádí (last - first) porovnání rovnosti a maximálně (last - first) přiřazení nových hodnot.

Příklad

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

Obrátí pořadí prvků v rozsahu.

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

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Obousměrný iterátor ukazující na pozici prvního prvku v oblasti, ve které jsou prvky permutovány.

last
Obousměrný iterátor ukazující na pozici po posledním prvku v oblasti, ve které jsou prvky permutovány.

Poznámky

Odkazovaný zdrojový rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Příklad

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

Obrátí pořadí prvků ve zdrojovém rozsahu při kopírování do cílového rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Obousměrný iterátor ukazující na pozici prvního prvku ve zdrojovém rozsahu, ve kterém jsou prvky permutovány.

last
Obousměrný iterátor ukazující na pozici po posledním prvku ve zdrojovém rozsahu, ve kterém jsou prvky permutovány.

result
Výstupní iterátor odkazující na pozici prvního prvku v cílovém rozsahu, do kterého se elementy kopírují.

Vrácená hodnota

Výstupní iterátor odkazující na pozici za posledním prvkem v cílovém rozsahu, do které se zkopírovala změněná posloupnost prvků.

Poznámky

Zdrojové a cílové rozsahy, na které odkazuje, musí být platné; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Příklad

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

Vymění prvky ve dvou sousedních rozsazích.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má otočit.

middle
Předávací iterátor definující hranici v rozsahu, který řeší pozici prvního prvku v druhé části oblasti, jejíž prvky se mají vyměňovat s prvky v první části rozsahu.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má otočit.

Poznámky

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Složitost je lineární. Provádí maximálně (last - first) prohození.

Příklad

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

Vymění prvky ve dvou sousedních rozsazích v rámci zdrojového rozsahu a zkopíruje výsledek do cílového rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má otočit.

middle
Předávací iterátor definující hranici v rozsahu, který řeší pozici prvního prvku v druhé části oblasti, jejíž prvky se mají vyměňovat s prvky v první části rozsahu.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má otočit.

result
Výstupní iterátor adresuje pozici prvního prvku v cílovém rozsahu.

Vrácená hodnota

Výstupní iterátor adresuje pozici po posledním prvku v cílovém rozsahu.

Poznámky

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Složitost je lineární. Provádí maximálně (last - first) prohození.

Příklad

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

Vyhledá první výskyt sekvence v cílovém rozsahu, jehož prvky jsou rovny prvkům v dané sekvenci prvků nebo jejichž prvky jsou ekvivalentní ve smyslu určeném binárním predikátem prvkům v dané sekvenci.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last1
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

first2
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má shodovat.

last2
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má shodovat.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

searcher
Prohledávací nástroj, který zapouzdřuje vzor, aby hledal, a vyhledávací algoritmus, který se má použít. Další informace o vyhledávacích objektech najdete v tématu default_searcher třída, boyer_moore_horspool_searcher třída a boyer_moore_searcher třída.

Vrácená hodnota

Forward iterator adresuje pozici prvního prvku první podsekvence, která odpovídá zadané sekvenci nebo která je ekvivalentní ve smyslu určeném binárním predikátem.

Poznámky

Použitý operator== k určení shody mezi prvkem a zadanou hodnotou musí mít vztah ekvivalence mezi jeho operandy.

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci je poslední pozice dosažitelná od prvního zvýšením.

Průměrná složitost je lineární vzhledem k velikosti prohledáného rozsahu. Složitost nejhoršího případu je také lineární vzhledem k velikosti hledané sekvence.

Příklad

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

Vyhledá první dílčí sekvenci v rozsahu zadaného počtu prvků s konkrétní hodnotou nebo vztahem k dané hodnotě podle binárního predikátu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má prohledávat.

last1
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má prohledávat.

count
Velikost podsekvence, kterou hledáte.

value
Hodnota prvků v posloupnosti, kterou hledáte.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Forward iterator adresuje pozici prvního prvku první podsekvence, která odpovídá zadané sekvenci nebo která je ekvivalentní ve smyslu určeném binárním predikátem.

Poznámky

Použitý operator== k určení shody mezi prvkem a zadanou hodnotou musí mít vztah ekvivalence mezi jeho operandy.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Složitost je lineární vzhledem k velikosti prohledáné položky.

Příklad

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

Spojí všechny prvky, které patří do jednoho seřazeného zdrojového rozsahu, ale ne do druhého seřazeného zdrojového rozsahu, do jednoho seřazeného cílového rozsahu. Binární predikát může určovat kritérium řazení.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresující pozici prvního prvku v prvním ze dvou seřazených zdrojových rozsahů, který má být sjednocený a seřazený do jedné oblasti představující rozdíl dvou zdrojových oblastí.

last1
Vstupní iterátor adresující pozici za posledním prvkem v první ze dvou seřazených zdrojových oblastí, které mají být sjednoceny a seřazeny do jedné oblasti představující rozdíl dvou zdrojových oblastí.

first2
Vstupní iterátor adresující pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených zdrojových rozsahů, které mají být sjednoceny a seřazeny do jedné oblasti představující rozdíl dvou zdrojových rozsahů.

last2
Vstupní iterátor adresující pozici za posledním prvkem ve druhé ze dvou po sobě jdoucích seřazených zdrojových oblastí, které se mají skládat a řadit do jedné oblasti představující rozdíl dvou zdrojových rozsahů.

result
Výstupní iterátor adresující pozici prvního prvku v cílovém rozsahu, kde se obě zdrojové oblasti mají sjednotit do jedné seřazené oblasti představující rozdíl dvou zdrojových oblastí.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek a false jinak.

Vrácená hodnota

Výstupní iterátor adresující pozici za posledním prvkem v seřazené cílové oblasti představující rozdíl dvou zdrojových oblastí.

Poznámky

Seřazené zdrojové oblasti, na které odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením.

Cílový rozsah by se neměl překrývat ani jeden ze zdrojových rozsahů a měl by být dostatečně velký, aby obsahoval první zdrojový rozsah.

Seřazené zdrojové rozsahy musí být uspořádány jako předběžná podmínka pro použití set_difference algoritmu v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů.

Operace je stabilní, protože relativní pořadí prvků v jednotlivých oblastech je zachováno v cílovém rozsahu. Sloučením algoritmů se nezmění zdrojové rozsahy.

Typy hodnot vstupních iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky. Pokud jsou v obou zdrojových oblastech ekvivalentní prvky, prvky v první oblasti před prvky z druhého zdrojového rozsahu v cílovém rozsahu. Pokud zdrojové oblasti obsahují duplicity prvku tak, aby v první zdrojové oblasti byly více než v druhé, bude cílová oblast obsahovat číslo, kterým výskyty těchto prvků v první zdrojové oblasti překročí výskyty těchto prvků ve druhém zdrojovém rozsahu.

Složitostalgoritmuho 2 * ((last1 - first1) + (last2 - first2)) - 1

Příklad

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

Sjednotí všechny prvky, které náleží do obou seřazených zdrojových rozsahů, do jednoho seřazeného cílového rozsahu, kde kritérium pořadí může být určeno binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresující pozici prvního prvku v prvním ze dvou seřazených zdrojových rozsahů, který má být sjednocený a seřazený do jedné oblasti představující průsečík obou zdrojových oblastí.

last1
Vstupní iterátor adresující pozici za posledním prvkem v první ze dvou seřazených zdrojových oblastí, které se mají skládat a řadit do jedné oblasti představující průnik dvou zdrojových oblastí.

first2
Vstupní iterátor adresující pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených zdrojových oblastí, které mají být sjednoceny a seřazeny do jedné oblasti představující průnik obou zdrojových oblastí.

last2
Vstupní iterátor adresující pozici za posledním prvkem v sekundě dvou po sobě jdoucích seřazených zdrojových rozsahů, které se mají skládat a řadit do jedné oblasti představující průsečík obou zdrojových oblastí.

result
Výstupní iterátor adresující pozici prvního prvku v cílovém rozsahu, kde se obě zdrojové oblasti mají sjednotit do jedné seřazené oblasti představující průsečík obou zdrojových oblastí.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek a false jinak.

Vrácená hodnota

Výstupní iterátor adresující pozici za posledním prvkem v seřazené cílové oblasti představující průnik dvou zdrojových oblastí.

Poznámky

Seřazené zdrojové oblasti, na které odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením.

Cílový rozsah by se neměl překrývat ani jeden ze zdrojových rozsahů a měl by být dostatečně velký, aby obsahoval cílový rozsah.

Seřazené zdrojové rozsahy musí být uspořádány jako předpoklad pro použití algoritmu sloučení v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů.

Operace je stabilní, protože relativní pořadí prvků v jednotlivých oblastech je zachováno v cílovém rozsahu. Rozsahy zdroje nejsou algoritmem upraveny.

Typy hodnot vstupních iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky. Pokud jsou v obou zdrojových oblastech ekvivalentní prvky, prvky v první oblasti před prvky z druhého zdrojového rozsahu v cílovém rozsahu. Pokud zdrojové oblasti obsahují duplicity prvku, bude cílový rozsah obsahovat maximální počet těchto prvků, které se vyskytují v obou zdrojových oblastech.

Složitostalgoritmuho 2 * ((last1 - first1) + (last2 - first2)) - 1

Příklad

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

Spojí všechny prvky, které patří k jednomu, ale ne oběma seřazeným zdrojovým rozsahům, do jediného seřazeného cílového rozsahu. Binární predikát může určovat kritérium řazení.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresující pozici prvního prvku v první ze dvou seřazených zdrojových oblastí, které mají být sjednoceny a seřazeny do jedné oblasti představující symetrický rozdíl dvou zdrojových rozsahů.

last1
Vstupní iterátor adresující pozici za posledním prvkem v první ze dvou seřazených zdrojových oblastí, které se mají skládat a řadit do jedné oblasti představující symetrický rozdíl dvou zdrojových rozsahů.

first2
Vstupní iterátor adresující pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených zdrojových rozsahů, které mají být sjednoceny a seřazeny do jedné oblasti představující symetrický rozdíl dvou zdrojových rozsahů.

last2
Vstupní iterátor adresující pozici za posledním prvkem v sekundě dvou po sobě jdoucích seřazených zdrojových rozsahů, které mají být sjednoceny a seřazeny do jedné oblasti představující symetrický rozdíl dvou zdrojových oblastí.

result
Výstupní iterátor adresující pozici prvního prvku v cílovém rozsahu, kde se obě zdrojové oblasti skládají do jedné seřazené oblasti představující symetrický rozdíl obou zdrojových rozsahů.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek a false jinak.

Vrácená hodnota

Výstupní iterátor adresující pozici za posledním prvkem v seřazené cílové oblasti představující symetrický rozdíl dvou zdrojových oblastí.

Poznámky

Seřazené zdrojové oblasti, na které odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením.

Cílový rozsah by se neměl překrývat ani jeden ze zdrojových rozsahů a měl by být dostatečně velký, aby obsahoval cílový rozsah.

Seřazené zdrojové rozsahy musí být uspořádány jako předběžná podmínka pro použití merge* algoritmu v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů.

Operace je stabilní, protože relativní pořadí prvků v jednotlivých oblastech je zachováno v cílovém rozsahu. Sloučením algoritmů se nezmění zdrojové rozsahy.

Typy hodnot vstupních iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky. Pokud jsou v obou zdrojových oblastech ekvivalentní prvky, prvky v první oblasti před prvky z druhého zdrojového rozsahu v cílovém rozsahu. Pokud zdrojové oblasti obsahují duplicitní položky prvku, bude cílová oblast obsahovat absolutní hodnotu čísla, kterým výskyty těchto prvků v jedné ze zdrojových oblastí překročí výskyty těchto prvků ve druhé zdrojové oblasti.

Složitostalgoritmuho 2 * ((last1 - first1) + (last2 - first2)) - 1

Příklad

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

Spojí všechny prvky, které patří alespoň do jednoho ze dvou seřazených zdrojových oblastí, do jednoho seřazeného cílového rozsahu. Binární predikát může určovat kritérium řazení.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresující pozici prvního prvku v prvním ze dvou seřazených zdrojových rozsahů, který má být sjednocený a seřazený do jedné oblasti představující sjednocení obou zdrojových rozsahů.

last1
Vstupní iterátor adresující pozici za posledním prvkem v první ze dvou seřazených zdrojových oblastí, které mají být sjednoceny a seřazeny do jedné oblasti představující sjednocení dvou zdrojových oblastí.

first2
Vstupní iterátor adresující pozici prvního prvku ve druhém ze dvou po sobě jdoucích seřazených zdrojových oblastí, které mají být sjednoceny a seřazeny do jedné oblasti představující sjednocení dvou zdrojových rozsahů.

last2
Vstupní iterátor adresující pozici za posledním prvkem ve druhé ze dvou po sobě jdoucích seřazených zdrojových oblastí, které se mají sjednocovat a seřadit do jedné oblasti představující sjednocení dvou zdrojových oblastí.

result
Výstupní iterátor adresující pozici prvního prvku v cílovém rozsahu, kde se obě zdrojové oblasti mají sjednocovat do jedné seřazené oblasti představující sjednocení dvou zdrojových rozsahů.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Binární predikát přebírá dva argumenty a měl by se vrátit true , když je první prvek menší než druhý prvek a false jinak.

Vrácená hodnota

Výstupní iterátor adresující pozici za posledním prvkem v seřazené cílové oblasti představující sjednocení dvou zdrojových oblastí.

Poznámky

Seřazené zdrojové oblasti, na které odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením.

Cílový rozsah by se neměl překrývat ani jeden ze zdrojových rozsahů a měl by být dostatečně velký, aby obsahoval cílový rozsah.

Seřazené zdrojové rozsahy musí být uspořádány jako předběžná podmínka pro použití merge algoritmu v souladu se stejným pořadím, jaké má algoritmus použít k seřazení kombinovaných rozsahů.

Operace je stabilní, protože relativní pořadí prvků v jednotlivých oblastech je zachováno v cílovém rozsahu. Rozsahy zdroje nejsou upraveny algoritmem merge.

Typy hodnot vstupních iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky. Pokud jsou v obou zdrojových oblastech ekvivalentní prvky, prvky v první oblasti před prvky z druhého zdrojového rozsahu v cílovém rozsahu. Pokud zdrojové oblasti obsahují duplicity prvku, bude cílový rozsah obsahovat maximální počet těchto prvků, které se vyskytují v obou zdrojových oblastech.

Složitost algoritmu je lineární s většinou 2 * ((last1 - first1) + (last2 - first2)) - 1 porovnání.

Příklad

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

Shuffles (změna uspořádání) prvků pro daný rozsah pomocí generátoru náhodných čísel.

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

Parametry

first
Iterátor na první prvek v rozsahu, který se má prohazovat včetně. Musí splňovat požadavky a RandomAccessIterator ValueSwappable.

last
Iterátor na poslední prvek v rozsahu, který má být prohazovaný, exkluzivní. Musí splňovat požadavky a RandomAccessIterator ValueSwappable.

gen
Generátor náhodných čísel, který shuffle() bude funkce používat pro danou operaci. Musí splňovat požadavky UniformRandomNumberGenerator

Poznámky

Další informace a vzorový kód, který používá shuffle(), naleznete v tématu <random>.

sort

Uspořádá prvky v zadaném rozsahu do nesestupného pořadí nebo podle setřiďovacího kritéria určeného binárním predikátem.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.

last
Iterátor náhodného přístupu adresuje pozici za posledním prvkem v oblasti, která se má seřadit.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Tento binární predikát přebírá dva argumenty a vrátí, true pokud jsou oba argumenty v pořadí a false jinak. Tato porovnávací funkce musí u párů prvků ze sekvence uložit striktní slabé pořadí. Další informace naleznete v tématu Algoritmy.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Prvky jsou ekvivalentní, ale nemusí se nutně rovnat, pokud ani jeden není menší než druhý. Algoritmus sort není stabilní a nezaručuje, že se zachová relativní pořadí ekvivalentních prvků. Algoritmus stable_sort zachová toto původní řazení.

Průměr složitosti řazení je O( N log N ), kde N = last - first.

Příklad

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

Převede haldu na seřazený rozsah.

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

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

Parametry

first
Iterátor náhodného přístupu adresuje pozici prvního prvku v cílové haldě.

last
Iterátor náhodného přístupu adresovaný pozici za posledním prvkem v cílové haldě.

pred
Uživatelem definovaný predikát objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Haldy mají dvě vlastnosti:

• První prvek je vždy největší.

• Prvky mohou být přidány nebo odebrány v logaritmickém čase.

Po aplikaci, pokud tento algoritmus, rozsah, na který byl použit, už není haldou.

sort_heap není stabilní řazení, protože relativní pořadí ekvivalentních prvků není nutně zachováno.

Haldy představují ideální způsob, jak implementovat prioritní fronty a používají se při implementaci třídy adaptéru priority_queue kontejneru standardní knihovny C++.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Složitost je maximálně N log N, kde N = last - first.

Příklad

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

Klasifikuje prvky v oblasti do dvou nesouvislých sad, přičemž prvky, které splňují jednoární predikát před prvky, které jej nesplňují, zachová relativní pořadí ekvivalentních prvků.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Obousměrný iterátor adresovaný pozici prvního prvku v rozsahu, který se má rozdělit.

last
Obousměrný iterátor adresovaný pozici po posledním prvku v rozsahu, který se má rozdělit.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud má být prvek klasifikován. Unární predikát přebírá jeden argument a vrátí true , pokud je splněn, nebo false pokud není splněn.

Vrácená hodnota

Obousměrný iterátor adresuje pozici prvního prvku v rozsahu tak, aby nevyhovuje predikátové podmínce.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Prvky a a a b jsou ekvivalentní, ale nemusí se nutně rovnat, pokud je false pred( a, b ) a pred( b, a ) je false, kde pred je predikát zadaný parametrem. Algoritmus stable_partition je stabilní a zaručuje zachování relativního pořadí ekvivalentních prvků. Algoritmus partition nemusí nutně zachovat toto původní řazení.

Příklad

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

Uspořádá prvky v zadaném rozsahu do nesestupného pořadí nebo podle setřiďovacího kritéria určeného binárním predikátem. Zachovává relativní pořadí ekvivalentních prvků.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Obousměrný iterátor adresovaný pozici prvního prvku v rozsahu, který se má seřadit.

last
Obousměrný iterátor adresovaný pozici za posledním prvkem v oblasti, která se má seřadit.

pred
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Poznámky

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku.

Prvky jsou ekvivalentní, ale nemusí se nutně rovnat, pokud ani jeden není menší než druhý. Algoritmus sort je stabilní a zaručuje zachování relativního pořadí ekvivalentních prvků.

Složitost doby stable_sort běhu závisí na množství dostupné paměti, ale nejlepší případ (vzhledem k dostatečné paměti) je O(N log N) a nejhorším případem je O(N (log N)^2), kde N = last - first. sort Obvykle je algoritmus rychlejší než stable_sort.

Příklad

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

První přepsání vyměňuje hodnoty dvou objektů. Druhé přepsání vyměňuje hodnoty mezi dvěma poli objektů.

template<class Type>
void swap(
    Type& left,
    Type& right);
template<class Type, size_t N>
void swap(
    Type (& left)[N],
    Type (& right)[N]);

Parametry

left
Pro první přepsání první objekt, který má mít jeho obsah vyměněný. Pro druhé přepsání první pole objektů, aby se jeho obsah vyměněl.

right
Pro první přepsání druhý objekt, který má mít jeho obsah vyměněný. Pro druhé přepsání má druhá pole objektů, aby se jeho obsah vyměněl.

Poznámky

První přetížení je určeno pro práci s jednotlivými objekty. Druhé přetížení prohodí obsah objektů mezi dvěma poli.

Příklad

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

Vymění prvky z jednoho rozsahu za prvky druhého rozsahu o stejné velikosti.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Iterátor dopředu ukazuje na první pozici první oblasti, jejíž prvky se mají vyměnit.

last1
Iterátor vpřed ukazuje na jednu za poslední pozici první oblasti, jejíž prvky se mají vyměnit.

first2
Dopředný iterátor ukazující na první pozici druhého rozsahu, jehož prvky se mají vyměnit.

Vrácená hodnota

Iterátor dopředu ukazuje na jednu za poslední pozici druhého rozsahu, jehož prvky se mají vyměnit.

Poznámky

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci je poslední pozice dosažitelná od prvního zvýšením. Druhá oblast musí být tak velká jako první oblast.

Složitost je lineární s posledními 1 - první1 prohozeními provedenými. Pokud se prohodí prvky z kontejnerů stejného typu, swap měla by se použít členová funkce z tohoto kontejneru, protože členová funkce má obvykle konstantní složitost.

Příklad

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

Použije zadaný objekt funkce na každý prvek ve zdrojovém rozsahu nebo na dvojici prvků ze dvou zdrojových oblastí. Potom zkopíruje návratové hodnoty objektu funkce do cílového rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first1
Vstupní iterátor adresuje pozici prvního prvku v první zdrojové oblasti, na které se má pracovat.

last1
Vstupní iterátor adresuje pozici za posledním prvkem v první zdrojové oblasti, na které se má pracovat.

first2
Vstupní iterátor adresuje pozici prvního prvku ve druhém zdrojovém rozsahu, na kterém se má pracovat.

result
Výstupní iterátor adresuje pozici prvního prvku v cílovém rozsahu.

func
Uživatelem definovaný objekt unární funkce použitý v první verzi algoritmu, který se použije pro každý prvek v první zdrojové oblasti nebo uživatelem definovaný objekt binární funkce (UD) použitý ve druhé verzi algoritmu, který se používá párově v pořadí dopředu, do dvou zdrojových oblastí.

Vrácená hodnota

Výstupní iterátor adresovaný pozici za posledním prvkem v cílovém rozsahu, který přijímá výstupní prvky transformované objektem funkce.

Poznámky

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v každé sekvenci musí být poslední pozice dosažitelná od prvního zvýšením. Cílová oblast musí být dostatečně velká, aby obsahovala transformovaný zdrojový rozsah.

Pokud je výsledek nastavený jako first1 v první verzi algoritmu, bude zdrojový a cílový rozsah stejný a pořadí se upraví. result Ale nesmí adresovat pozici v rozsahu [ +first1 1, last1).

Složitost je lineární. Provádí maximálně (last1 - first1) porovnání.

Příklad

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

Odebere duplicitní prvky, které jsou vedle sebe v zadaném rozsahu.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku v rozsahu, který se má zkontrolovat pro duplicitní odebrání.

last
Dopředný iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má zkontrolovat pro duplicitní odebrání.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Předaný iterátor na nový konec upravené sekvence, který neobsahuje žádné po sobě jdoucí duplicity, adresuje pozici za posledním prvkem, který nebyl odebrán.

Poznámky

Obě formy algoritmu odeberou druhou duplicitu po sobě jdoucí dvojice stejných prvků.

Operace algoritmu je stabilní, takže relativní pořadí nedeletovaných prvků se nezmění.

Odkazovaný rozsah musí být platný; všechny ukazatele musí být dereferenceable a v rámci sekvence je poslední pozice dosažitelná od prvního přírůstku. Algoritmus nemění unique počet prvků v sekvenci a prvky za koncem upravené sekvence se nedají odvodit, ale nezadají se.

Složitost je lineární a vyžaduje (last - first) - 1 porovnání.

Seznam poskytuje efektivnější členovou funkci "jedinečnou", která může lépe fungovat.

Tyto algoritmy nelze použít v asociativním kontejneru.

Příklad

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

Zkopíruje prvky ze zdrojového rozsahu do cílového rozsahu s výjimkou duplicitních prvků, které jsou vedle sebe.

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

Parametry

exec
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresovaný pozici prvního prvku ve zdrojovém rozsahu, který se má zkopírovat.

last
Dopředný iterátor adresovaný pozici za posledním prvkem ve zdrojovém rozsahu, který se má zkopírovat.

result
Výstupní iterátor adresovaný pozici prvního prvku v cílovém rozsahu, který přijímá kopii s po sobě jdoucími duplicitními položkami.

pred
Uživatelem definovaný predikát objekt funkce, který definuje podmínku, která má být splněna, pokud mají být dva prvky považovány za ekvivalentní. Binární predikát přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Výstupní iterátor adresovaný pozici za posledním prvkem v cílovém rozsahu, který přijímá kopii s odstraněnými po sobě jdoucími duplicitami.

Poznámky

Obě formy algoritmu odeberou druhou duplicitu po sobě jdoucí dvojice stejných prvků.

Operace algoritmu je stabilní, takže relativní pořadí nedeletovaných prvků se nezmění.

Rozsahy, na které se odkazuje, musí být platné; všechny ukazatele musí být dereferencovatelné a v rámci sekvence je poslední pozice dosažitelná od prvního zvýšením.

Složitost je lineární a vyžaduje (last - first) porovnání.

Příklad

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

Vyhledá pozici prvního prvku v uspořádané oblasti, která má hodnotu větší než zadanou hodnotu. Binární predikát určuje kritérium řazení.

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

Parametry

first
Pozice prvního prvku v oblasti, která se má prohledávat.

last
Pozice jedna za posledním prvkem v oblasti, která se má prohledávat.

value
Hodnota v seřazené oblasti, která musí být překročena hodnotou prvku adresovaného iterátorem vráceným iterátorem.

pred
Uživatelem definovaný predikát porovnávací objekt funkce, který definuje smysl, ve kterém je jeden prvek menší než jiný. Predikát porovnání přebírá dva argumenty a vrací true se, když jsou splněny a false kdy nejsou splněny.

Vrácená hodnota

Dopředný iterátor na pozici prvního prvku, který má hodnotu větší než zadaná hodnota.

Poznámky

Seřazený zdrojový rozsah, na který odkazuje, musí být platný; všechny iterátory musí být odvozovatelné a v pořadí musí být poslední pozice dosažitelná od prvního zvýšením.

Seřazený rozsah je předběžnou podmínkou použití upper_bound a kde je kritérium řazení stejné jako kritérium stanovené predikátem porovnání.

Rozsah není upraven .upper_bound

Typy hodnot předávaných iterátorů musí být menší než srovnatelné, aby bylo možné je uspořádat. To znamená, že vzhledem k dvěma prvkům můžete určit, zda je jedna menší než druhá, nebo že jsou ekvivalentní. (Ekvivalent znamená, že ani jedno není menší než ostatní.) Výsledkem tohoto porovnání je řazení mezi žádnými prvky.

Složitost algoritmu je logaritmická pro iterátory náhodného přístupu a lineární v opačném případě s počtem kroků úměrných (last - first).

Příklad

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