`<algorithm>`, funkcje

Artykuł
10/12/2023

`adjacent_find`

Wyszukuje dwa sąsiadujące elementy, które są równe lub spełniają określony warunek.

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
Zasady wykonywania do użycia.

first
Iterator do przodu na pozycji pierwszego elementu w zakresie do wyszukania.

last
Iterator do przodu na pozycji 1 obok ostatniego elementu w zakresie do wyszukania.

pred
Predykat binarny dający warunek, który ma być spełniony przez wartości sąsiednich elementów w wyszukiwanym zakresie.

Wartość zwracana

Iterator do przodu do pierwszego z sąsiednich elementów, które są równe sobie (w pierwszej wersji) lub spełniają warunek podany przez predykat binarny (w drugiej wersji), jeśli taka para elementów zostanie znaleziona. W przeciwnym razie zwracany jest iterator wskazujący last .

Uwagi

Algorytm adjacent_find jest algorytmem sekwencji niemutującym. Zakres do wyszukania musi być prawidłowy. Wszystkie wskaźniki muszą być wyłuszające, a ostatnia pozycja musi być osiągalna od pierwszego przez przyrost. Złożoność czasowa algorytmu jest liniowa w liczbie elementów zawartych w zakresie.

Element operator== używany do określania dopasowania między elementami musi nakładać relację równoważności między operandami.

Przykład

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

Zwraca wartość true , gdy warunek jest obecny w każdym elemecie w danym zakresie.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący, gdzie rozpocząć sprawdzanie warunku. Iterator oznacza, gdzie rozpoczyna się zakres elementów.

last
Iterator wejściowy wskazujący koniec zakresu elementów do sprawdzenia warunku.

pred
Warunek do przetestowania. pred jest obiektem funkcji predykatu jednoargumentowego zdefiniowanego przez użytkownika, który definiuje warunek, który ma zostać spełniony przez sprawdzany element. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Zwraca true wartość, jeśli warunek zostanie wykryty w każdym elemecie w wskazanym zakresie lub jeśli zakres jest pusty, a false w przeciwnym razie.

Uwagi

Funkcja szablonu zwraca true tylko wtedy, gdy dla każdego N z nich w zakresie [0, last - first)predykat pred(*(first + N)) to true.

Przykład

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

Zwraca wartość true , gdy warunek występuje co najmniej raz w określonym zakresie elementów.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący, gdzie rozpocząć sprawdzanie zakresu elementów warunku.

last
Iterator wejściowy wskazujący koniec zakresu elementów do sprawdzenia warunku.

pred
Warunek do przetestowania. Ten test jest dostarczany przez obiekt funkcji predykatu zdefiniowanego przez użytkownika. Predykat definiuje warunek, który ma być spełniony przez testowany element. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Zwraca true wartość, jeśli warunek zostanie wykryty co najmniej raz w wskazanym zakresie, false jeśli warunek nigdy nie zostanie wykryty.

Uwagi

Funkcja szablonu zwraca true tylko wtedy, gdy dla niektórych N w zakresie

[0, last - first), predykat pred(*(first + N)) ma wartość true.

Przykład

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

Sprawdza, czy istnieje element w posortowanego zakresu, który jest równy określonej wartości, czy jest równoważny w sensie określonym przez predykat binarny.

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
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do przeszukania.

value
Wartość wymagana do dopasowania przez wartość elementu lub musi spełniać warunek z wartością elementu określoną przez predykat binarny.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat binarny przyjmuje dwa argumenty i zwraca, true gdy jest spełniony, a false gdy nie jest spełniony.

Wartość zwracana

true jeśli element znajduje się w zakresie równym lub równoważnym z określoną wartością; w przeciwnym razie, false.

Uwagi

Posortowany zakres źródłowy, do których odwołuje się odwołanie, musi być prawidłowy; wszystkie wskaźniki muszą być wyłuszające, a w ramach sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Posortowany zakres musi być ułożony jako warunek wstępny do zastosowania algorytmu binary_search zgodnie z tą samą kolejnością, co ma być używane przez algorytm do sortowania połączonych zakresów.

Zakresy źródłowe nie są modyfikowane przez binary_searchprogram .

Typy wartości iteratorów przesyłania dalej muszą być mniej niż porównywalne do uporządkowanych. To znaczy, biorąc pod uwagę dwa elementy, można określić, że jeden jest mniejszy niż drugi, lub że są równoważne. (W tym przypadku odpowiednik oznacza, że żadna z nich nie jest mniejsza niż druga). To porównanie powoduje kolejność między elementami niekwentnych.

Złożoność algorytmu jest logarytmiczna dla iteratorów dostępu losowego i liniowego w przeciwnym razie z liczbą kroków proporcjonalnych do (last-first).

Przykład

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

Porównuje wartość z górną i dolną granicą i zwraca odwołanie do wartości, jeśli znajduje się między granicami, lub odwołaniem do górnej lub dolnej granicy, jeśli wartość jest powyżej lub poniżej nich, odpowiednio.

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
Wartość do porównania z wartościami upper i lower.

lower
Dolna granica wartości do zaciśnięć value .

upper
Górna granica wartości do zacisku value .

pred
Predykat używany do porównywania value z elementami lower lub upper. Predykat porównania przyjmuje dwa argumenty i zwraca true , jeśli pierwszy jest w pewnym sensie mniejszy niż drugi, a w przeciwnym razie false.

Wartość zwracana

Zwraca odwołanie do lower , jeśli value < lower, lub odwołanie do upper if upper < value. W przeciwnym razie zwraca odwołanie do valueelementu .

Uwagi

Zachowanie jest niezdefiniowane, jeśli upper jest mniejsze niż lower.

`copy`

Przypisuje wartości elementów z zakresu źródłowego do zakresu docelowego, iterując przez sekwencję źródłową elementów oraz przypisując im nowe pozycje w kierunku do przodu.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie źródłowym.

last
Iterator wejściowy odnoszący się do pozycji, która znajduje się obok ostatniego elementu w zakresie źródłowym.

destBeg
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie docelowym.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji, która znajduje się obok ostatniego elementu w zakresie docelowym, czyli adresów result iteratora + ( - lastfirst).

Uwagi

Zakres źródłowy musi być prawidłowy i musi być wystarczająco dużo miejsca w miejscu przeznaczenia, aby pomieścić wszystkie elementy kopiowane.

Ponieważ algorytm kopiuje elementy źródłowe w kolejności rozpoczynającej się od pierwszego elementu, zakres docelowy może nakładać się na zakres źródłowy, pod warunkiem, last że pozycja zakresu źródłowego nie jest zawarta w zakresie docelowym. copy Można użyć do przesunięcia elementów w lewo, ale nie po prawej stronie, chyba że nie ma nakładania się między zakresami źródłowymi i docelowymi. Aby przejść do prawej strony dowolnej liczby pozycji, użyj algorytmu copy_backward .

Algorytm copy modyfikuje tylko wartości wskazywane przez iteratory, przypisując nowe wartości do elementów w zakresie docelowym. Nie można jej użyć do utworzenia nowych elementów i nie można bezpośrednio wstawić elementów do pustego kontenera.

Przykład

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

Przypisuje wartości elementów z zakresu źródłowego do zakresu docelowego, iterując przez sekwencję źródłową elementów oraz przypisując im nowe pozycje w kierunku do tyłu.

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

Parametry

first
Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w zakresie źródłowym.

last
Iterator dwukierunkowy odnoszący się do pierwszej pozycji po elemencie końcowym w zakresie źródłowym.

destEnd
Iterator dwukierunkowy odnoszący się do pierwszej pozycji po elemencie końcowym w zakresie docelowym.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji, która znajduje się obok ostatniego elementu w zakresie docelowym, czyli iterator adresów destEnd - (last - first).

Uwagi

Zakres źródłowy musi być prawidłowy i musi być wystarczająco dużo miejsca w miejscu przeznaczenia, aby pomieścić wszystkie elementy kopiowane.

Algorytm copy_backward nakłada bardziej rygorystyczne wymagania niż copy algorytm. Oba iteratory, wejściowy i wyjściowy muszą być dwukierunkowe.

Algorytmy copy_backward i move_backward są jedynymi algorytmami biblioteki standardowej języka C++, które wyznaczają zakres danych wyjściowych za pomocą iteratora wskazującego koniec zakresu docelowego.

Ponieważ algorytm kopiuje elementy źródłowe w kolejności rozpoczynającej się od ostatniego elementu, zakres docelowy może nakładać się na zakres źródłowy, pod warunkiem, first że pozycja zakresu źródłowego nie jest zawarta w zakresie docelowym. copy_backward Można użyć do przesunięcia elementów w prawo, ale nie po lewej stronie, chyba że nie ma nakładania się między zakresami źródłowymi i docelowymi. Aby przejść do lewej dowolnej liczby pozycji, użyj algorytmu copy .

Algorytm copy_backward modyfikuje tylko wartości wskazywane przez iteratory, przypisując nowe wartości do elementów w zakresie docelowym. Nie można jej użyć do utworzenia nowych elementów i nie można bezpośrednio wstawić elementów do pustego kontenera.

Przykład

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

W zakresie elementów kopiuje elementy, które są true dla określonego warunku.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący początek zakresu w celu sprawdzenia warunku.

last
Iterator wejściowy wskazujący koniec zakresu.

dest
Iterator danych wyjściowych wskazujący miejsce docelowe skopiowanych elementów.

pred
Warunek, w którym każdy element w zakresie jest testowany. Ten warunek jest dostarczany przez obiekt funkcji predykatu zdefiniowanego przez użytkownika. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Iterator danych wyjściowych dest , który jest równy przyrostowi raz dla każdego elementu spełniającego warunek. Innymi słowy, zwracana wartość minus dest odpowiada liczbie skopiowanych elementów.

Uwagi

Funkcja szablonu ocenia

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

raz dla każdego N w zakresie [0, last - first), dla ściśle rosnących N wartości rozpoczynających się od najniższej wartości. Jeśli dest i first wyznaczyć regiony magazynu, dest nie może znajdować się w zakresie [ first, last ).

Przykład

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

Kopiuje określoną liczbę elementów.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący, skąd mają być kopiujące elementy.

count
Typ liczby całkowitej ze znakiem lub bez znaku określający liczbę elementów do skopiowania.

dest
Iterator danych wyjściowych wskazujący miejsce kopiowania elementów do.

Wartość zwracana

Zwraca iterator danych wyjściowych, do którego zostały skopiowane elementy. Jest taka sama jak zwrócona wartość parametru dest .

Uwagi

Funkcja szablonu oblicza *(dest + N) = *(first + N)) raz dla każdego N z nich w zakresie [0, count), w celu ścisłego zwiększania wartości rozpoczynających N się od najniższej wartości. Następnie zwraca wartość dest + N. Jeśli dest i first wyznaczyć regiony magazynu, dest nie może znajdować się w zakresie [first, last).

Przykład

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

Zwraca liczbę elementów w zakresie, których wartości pasują do określonej wartości.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie, który ma być przechodziny.

last
Iterator danych wejściowych odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma być przechodziny.

value
Wartość elementów do zliczenia.

Wartość zwracana

Typ różnicy InputIterator , który zlicza liczbę elementów w zakresie [first, last), które mają wartość value.

Uwagi

Używany operator== do określania dopasowania między elementem a określoną wartością musi narzucić relację równoważności między operandami.

Ten algorytm jest uogólniony do zliczania elementów, które spełniają wszelkie predykaty z funkcją count_ifszablonu .

Przykład

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

Zwraca liczbę elementów w zakresie, których wartości spełniają określony warunek.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie do wyszukania.

last
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać przeszukany.

pred
Obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek, który ma zostać spełniony, jeśli element ma zostać zliczany. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Liczba elementów spełniających warunek określony przez predykat.

Uwagi

Ta funkcja szablonu to uogólnianie algorytmu count, zastępując predykat "równa się określonej wartości" dowolnym predykatem.

Przykład

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

Porównuje dwa zakresy elementu według elementu równości lub równoważności w sensie określonym przez predykat binarny.

Użyj std::equal podczas porównywania elementów w różnych typach kontenerów (na przykład vector i list) lub podczas porównywania różnych typów elementów lub podczas porównywania podzestawów kontenerów. W przeciwnym razie podczas porównywania elementów tego samego typu w tym samym typie kontenera należy użyć elementu innego niż element członkowski operator== podany dla każdego kontenera.

Użyj przeciążeń dwuzakresowych w kodzie C++14, ponieważ przeciążenia, które przyjmują tylko jeden iterator dla drugiego zakresu, nie będą wykrywać różnic, jeśli drugi zakres jest dłuższy niż pierwszy zakres. Te przeciążenia spowodują niezdefiniowane zachowanie, jeśli drugi zakres jest krótszy niż pierwszy zakres.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym zakresie do przetestowania.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym zakresie, który ma zostać przetestowany.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim zakresie do przetestowania.

last2
Iterator wejściowy odnoszący się do pozycji jednego ostatniego elementu w drugim zakresie do przetestowania.

pred
Obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek, który ma zostać spełniony, jeśli dwa elementy mają być traktowane jako równoważne. Predykat binarny przyjmuje dwa argumenty i zwraca, true gdy jest spełniony, a false gdy nie jest spełniony.

Wartość zwracana

true jeśli i tylko wtedy, gdy zakresy są identyczne lub równoważne w predykacie binarnym podczas porównywania elementu według elementu; w przeciwnym razie, false.

Uwagi

Zakres do przeszukania musi być prawidłowy; wszystkie iteratory muszą być wyłuszające, a ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Jeśli te dwa zakresy są równe, złożoność czasowa algorytmu jest liniowa w liczbie elementów zawartych w zakresie. W przeciwnym razie funkcja natychmiast zwraca wartość false.

Nie potrzebujesz ani operator== predykatu zdefiniowanego przez użytkownika, aby narzucić relację równoważności, która jest symetryczna, refleksyjna i przechodnia między operandami.

Przykład

#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`

Biorąc pod uwagę uporządkowany zakres, znajduje podwojenie, w którym wszystkie elementy są równoważne danej wartości.

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
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do przeszukania.

value
Wyszukiwana wartość w uporządkowanym zakresie.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i zwraca true , gdy jest spełniony i false gdy nie jest spełniony.

Wartość zwracana

Para iteratorów przesyłania dalej, które określają podrange zawarte w wyszukiwanym zakresie, w którym wszystkie elementy są równoważne value w sensie zdefiniowanym przez używany predykat binarny ( pred lub domyślny, mniejszy niż).

Jeśli żadne elementy w zakresie są równoważne value, iteratory przesyłania dalej w zwróconej parze są równe i określają punkt, w którym value można wstawić bez zakłócania kolejności zakresu.

Uwagi

Pierwszy iterator pary zwróconej przez algorytm to lower_bound, a drugi iterator to upper_bound.

Zakres musi być posortowany zgodnie z predykatem podanym w .equal_range Jeśli na przykład użyjesz predykatu większego niż predykat, zakres musi być posortowany w kolejności malejącej.

Elementy w prawdopodobnie pustym podrange zdefiniowanym przez parę iteratorów zwróconych equal_range przez element będą równoważne wartości w sensie zdefiniowanym przez używany predykat.

Złożoność algorytmu jest logarytmiczna dla iteratorów dostępu losowego i liniowego w przeciwnym razie z liczbą kroków proporcjonalnych do (last - first).

Przykład

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

Przypisuje tę samą nową wartość każdemu elementowi w określonym zakresie.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie, który ma być przechodziny.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać przechyliony.

value
Wartość, która ma zostać przypisana do elementów w zakresie [first, last).

Uwagi

Zakres docelowy musi być prawidłowy; wszystkie wskaźniki muszą być wyłuszające, a ostatnia pozycja jest osiągalna od pierwszego przez inkrementację. Złożoność jest liniowa z rozmiarem zakresu.

Przykład

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

Przypisuje nową wartość do określonej liczby elementów w zakresie rozpoczynającym się od określonego elementu.

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
Zasady wykonywania do użycia.

first
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie, który ma zostać przypisany do wartości value.

count
Typ liczby całkowitej ze znakiem lub bez znaku określający liczbę elementów, które mają zostać przypisane do wartości.

value
Wartość, która ma zostać przypisana do elementów w zakresie [first, first + count).

Wartość zwracana

Iterator do elementu, który jest zgodny z ostatnim elementem wypełnionym, jeśli count> zero, w przeciwnym razie pierwszy element.

Uwagi

Przykład

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

Lokalizuje pozycję pierwszego wystąpienia elementu w zakresie, który ma określoną wartość.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie, który ma być wyszukiwany pod kątem określonej wartości.

last
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do wyszukania określonej wartości.

value
Wartość do wyszukania.

Wartość zwracana

Iterator wejściowy odnoszący się do pierwszego wystąpienia określonej wartości w wyszukiwanym zakresie. Jeśli żaden element nie zostanie znaleziony z równoważną wartością, zwraca wartość last.

Uwagi

Używany operator== do określania dopasowania między elementem a określoną wartością musi narzucić relację równoważności między operandami.

Aby zapoznać się z przykładem kodu przy użyciu metody find(), zobacz find_if.

`find_end`

Wyszukuje w zakresie ostatnią podsekwencję, która jest identyczna z określoną sekwencją lub jest równoważna w sensie określonym przez predykat binarny.

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
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last1
Iterator do przodu odnoszący się do pozycji 1 obok ostatniego elementu w zakresie, który ma zostać przeszukany.

first2
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do wyszukania.

last2
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do wyszukania.

Wartość zwracana

Iterator do przodu odnoszący się do pozycji pierwszego elementu ostatniego podsekwencjonowania w ciągu [first1, last1), który odpowiada określonej sekwencji [first2, last2).

Uwagi

Używany operator== do określania dopasowania między elementem a określoną wartością musi narzucić relację równoważności między operandami.

Zakresy, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w każdej sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Przykład

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

Wyszukuje pierwsze wystąpienie dowolnej z kilku wartości w zakresie docelowym. Lub wyszukuje pierwsze wystąpienie dowolnego z kilku elementów, które są równoważne w sensie określonym przez predykat binarny do określonego zestawu elementów.

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
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last1
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do przeszukania.

first2
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie, który ma być dopasowany.

last2
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma być dopasowany.

Wartość zwracana

Iterator do przodu odnoszący się do pozycji pierwszego elementu pierwszego podsekwencjonowania, który pasuje do określonej sekwencji lub jest równoważny w sensie określonym przez predykat binarny.

Uwagi

Używany operator== do określania dopasowania między elementem a określoną wartością musi narzucić relację równoważności między operandami.

Przykład

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

Lokalizuje pozycję pierwszego wystąpienia elementu w zakresie, który spełnia określony warunek.

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
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie do wyszukania.

last
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać przeszukany.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu lub wyrażenie lambda, które definiuje warunek, który ma być spełniony przez wyszukiwany element. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true , jeśli jest spełniony, lub false jeśli nie jest spełniony. Podpis pred musi mieć bool pred(const T& arg);wartość , gdzie T jest typem, do którego InputIterator można niejawnie konwertować w przypadku wyłudzenia. Słowo const kluczowe jest wyświetlane tylko w celu zilustrowania, że obiekt funkcji lub lambda nie powinien modyfikować argumentu.

Wartość zwracana

Iterator wejściowy, który odwołuje się do pierwszego elementu w zakresie, który spełnia warunek określony przez predykat (predykat powoduje w truepliku ). Jeśli żaden element nie zostanie znaleziony w celu spełnienia predykatu, zwraca wartość last.

Uwagi

Ta funkcja szablonu to uogólnianie algorytmu find, zastępując predykat "równa się określonej wartości" dowolnym predykatem. Aby uzyskać przeciwieństwo logiczne (znajdź pierwszy element, który nie spełnia wymagań predykatu), zobacz find_if_not.

Przykład

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

Zwraca pierwszy element w wskazanym zakresie, który nie spełnia warunku.

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
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie do wyszukania.

last
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać przeszukany.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu lub wyrażenie lambda, które definiuje warunek, który nie jest spełniony przez wyszukiwany element. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true , jeśli jest spełniony, lub false jeśli nie jest spełniony. Podpis pred musi mieć bool pred(const T& arg);wartość , gdzie T jest typem, do którego InputIterator można niejawnie konwertować w przypadku wyłudzenia. Słowo const kluczowe jest wyświetlane tylko w celu zilustrowania, że obiekt funkcji lub lambda nie powinien modyfikować argumentu.

Wartość zwracana

Iterator wejściowy, który odwołuje się do pierwszego elementu w zakresie, który nie spełnia warunku określonego przez predykat (predykat powoduje wystąpienie ).false Jeśli wszystkie elementy spełniają predykat (predykat daje wynik true dla każdego elementu), zwraca wartość last.

Uwagi

Aby zapoznać się z przykładem kodu, który można łatwo dostosować do find_if_not()elementu , zobacz find_if.

`for_each`

Stosuje określony obiekt funkcji do każdego elementu w kolejności do przodu w zakresie i zwraca obiekt funkcji.

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
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie do działania.

last
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie obsługiwanym.

func
Obiekt funkcji zdefiniowany przez użytkownika, który jest stosowany do każdego elementu w zakresie.

Wartość zwracana

Kopia obiektu funkcji po zastosowaniu go do wszystkich elementów w zakresie.

Uwagi

Algorytm for_each jest elastyczny, umożliwiając modyfikację każdego elementu w zakresie na różne sposoby określone przez użytkownika. Funkcje templatized mogą być ponownie używane w zmodyfikowanym formularzu, przekazując różne parametry. Funkcje zdefiniowane przez użytkownika mogą gromadzić informacje w stanie wewnętrznym, które algorytm może zwrócić po przetworzeniu wszystkich elementów w zakresie.

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszające, a w ramach sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Złożoność jest liniowa z co najwyżej (last - first) porównaniami.

Przykład

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

Stosuje określony obiekt funkcji do określonej liczby elementów w zakresie rozpoczynającym się od określonego elementu.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy na pozycji pierwszego elementu w zakresie do działania.

count
Liczba elementów do działania.

func
Obiekt funkcji zdefiniowany przez użytkownika, który ma być stosowany do każdego elementu w zakresie [first, first + count).

Wartość zwracana

Iterator do elementu, który jest zgodny z ostatnim elementem przetworzonym, jeśli count> zero, w przeciwnym razie pierwszy element.

Uwagi

count musi być nieujemna i musi istnieć co najmniej count elementy w zakresie rozpoczynającym się od first.

Przykład

W tym przykładzie zdefiniowano klasę obiektu funkcji. Kod produkcyjny często używa metody , lambda aby uzyskać ten sam wynik z mniejszym kodem.

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

Przypisuje wartości generowane przez obiekt funkcji do każdego elementu w zakresie.

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
Iterator do przodu na pozycji pierwszego elementu w zakresie, do którego mają być przypisane wartości.

last
Iterator do przodu na pozycji 1 obok ostatniego elementu w zakresie, do którego mają być przypisane wartości.

gen
Obiekt funkcji, który jest wywoływany bez argumentów, aby wygenerować wartości, które mają być przypisane do każdego z elementów w zakresie.

Uwagi

Obiekt funkcji jest wywoływany dla każdego elementu w zakresie i nie musi zwracać tej samej wartości za każdym razem, gdy jest wywoływany. Może na przykład odczytywać z pliku lub odwoływać się do i modyfikować stan lokalny. Typ wyniku generatora musi być konwertowany na typ wartości iteratora do przodu dla zakresu.

Zakres, do których odwołuje się odwołanie, musi być prawidłowy. Wszystkie wskaźniki muszą być wyłuszające, a w ramach sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Złożoność jest liniowa, z dokładnie last - first wywołaniami wykonanymi do generatora.

Przykład

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

Przypisuje wartości generowane przez obiekt funkcji do określonej liczby elementów w zakresie. Zwraca pozycję jedną obok ostatniej przypisanej wartości.

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
Zasady wykonywania do użycia.

first
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie, do którego mają być przypisane wartości.

count
Typ liczby całkowitej ze znakiem lub bez znaku określający liczbę elementów, które mają zostać przypisane przez funkcję generatora.

gen
Obiekt funkcji, który jest wywoływany bez argumentów używany do generowania wartości, które mają być przypisane do każdego z elementów w zakresie.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszające, a w ramach sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Złożoność jest liniowa, przy czym wymagane są dokładnie count wywołania generatora.

Przykład

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

Sprawdza, czy jeden posortowany zakres zawiera wszystkie elementy zawarte w drugim posortowanym zakresie, gdzie kryterium szeregowania lub równoważności między elementami może zostać określone przez predykat binarny.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym z dwóch posortowanych zakresów źródłowych do przetestowania pod kątem tego, czy wszystkie elementy drugiego znajdują się w pierwszym.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym z dwóch posortowanych zakresów źródłowych do przetestowania, czy wszystkie elementy drugiego znajdują się w pierwszym.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych do przetestowania pod kątem tego, czy wszystkie elementy drugiego znajdują się w pierwszym.

last2
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych do przetestowania pod kątem tego, czy wszystkie elementy drugie są zawarte w pierwszym.

Wartość zwracana

true jeśli pierwszy posortowany zakres zawiera wszystkie elementy w drugim posortowany zakres; w przeciwnym razie, false.

Uwagi

Innym sposobem myślenia o tym teście jest określenie, czy drugi zakres źródłowy jest podzbiorem pierwszego zakresu źródłowego.

Posortowane zakresy źródłowe, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w ramach każdej sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Jako warunek wstępny stosowania algorytmu includes, posortowane zakresy źródłowe muszą być ułożone z tą samą kolejnością, która jest używana przez algorytm do sortowania połączonych zakresów.

Zakresy źródłowe nie są modyfikowane przez algorytm merge.

Złożoność algorytmu jest liniowa z co najwyżej 2 * ((last1 - first1) + (last2 - first2)) - 1 porównaniami dla brakowych zakresów źródłowych.

Przykład

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

Łączy elementy z dwóch następujących po sobie posortowanych zakresów w pojedynczy posortowany zakres, gdzie kryterium szeregowania może być określone przez predykat binarny.

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
Zasady wykonywania do użycia.

first
Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w pierwszym z dwóch kolejnych posortowanych zakresów, które mają zostać połączone i posortowane w jeden zakres.

middle
Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w drugim z dwóch kolejnych posortowanych zakresów, które mają zostać połączone i posortowane w jeden zakres.

last
Iterator dwukierunkowy odnoszący się do pozycji jednej obok ostatniego elementu w drugim z dwóch kolejnych posortowanych zakresów, które mają zostać połączone i posortowane w jeden zakres.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Uwagi

Posortowane kolejne zakresy, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w ramach każdej sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Posortowane kolejne zakresy muszą być ułożone jako warunek wstępny do zastosowania algorytmu inplace_merge zgodnie z tą samą kolejnością, co ma być używane przez algorytm do sortowania połączonych zakresów. Operacja jest stabilna, ponieważ względna kolejność elementów w każdym zakresie jest zachowywana. Jeśli istnieją równoważne elementy w obu zakresach źródłowych, element jest pierwszym zakresem poprzedzającym element z drugiego w połączonym zakresie.

Złożoność zależy od dostępnej pamięci, ponieważ algorytm przydziela pamięć do tymczasowego buforu. Jeśli jest dostępna wystarczająca ilość pamięci, najlepszym przypadkiem jest liniowa z (last - first) - 1 porównaniami; jeśli nie jest dostępna pamięć pomocnicza, najgorszy przypadek to N log(N), gdzie - Nlast = first .

Przykład

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

Zwraca wartość true , jeśli elementy w określonym zakresie tworzą stertę.

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
Zasady wykonywania do użycia.

first
Iterator dostępu losowego wskazujący początek zakresu w celu sprawdzenia sterta.

last
Iterator dostępu losowego wskazujący koniec zakresu.

pred
Warunek do przetestowania elementów. Predykat porównania przyjmuje dwa argumenty i zwraca wartość true lub false.

Wartość zwracana

Zwraca wartość true , jeśli elementy w określonym zakresie tworzą stertę, false jeśli nie.

Uwagi

Pierwsza funkcja szablonu zwraca wartość is_heap_until(first , last) == last.

Druga funkcja szablonu zwraca

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

is_heap_until

Zwraca iterator umieszczony w pierwszym elememencie w zakresie [ first, last), który nie spełnia warunku porządkowania sterty lub end jeśli zakres tworzy stertę.

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
Zasady wykonywania do użycia.

first
Iterator dostępu losowego, który określa pierwszy element zakresu, aby sprawdzić stertę.

last
Iterator dostępu losowego, który określa koniec zakresu, aby sprawdzić stertę.

pred
Predykat binarny określający ścisły słaby warunek porządkowania, który definiuje stertę. Domyślny predykat jest std::less<> wtedy, gdy pred nie jest określony.

Wartość zwracana

Zwraca wartość last , jeśli określony zakres tworzy stertę lub zawiera jeden lub mniej elementów. W przeciwnym razie zwraca iterator pierwszego elementu, który nie spełnia warunku sterty.

Uwagi

Pierwsza funkcja szablonu zwraca ostatni iterator next w miejscu, w [first, last) którym [first, next) jest stertą uporządkowaną przez obiekt std::less<>funkcji . Jeśli odległość last - first jest mniejsza niż 2, funkcja zwraca wartość last.

Druga funkcja szablonu zachowuje się tak samo jak pierwsza, z tą różnicą, że używa predykatu pred zamiast std::less<> jako warunku porządkowania stert.

is_partitioned

Zwraca wartość true , jeśli wszystkie elementy w danym zakresie, które testuje true warunek, pochodzą przed wszystkimi elementami testowymi 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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący, gdzie zakres zaczyna sprawdzać warunek.

last
Iterator wejściowy wskazujący koniec zakresu.

pred
Warunek do przetestowania. Ten test jest dostarczany przez obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek, który ma zostać spełniony przez wyszukiwany element. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Zwraca wartość true , gdy wszystkie elementy w danym zakresie, które testuje true warunek, pochodzą przed wszystkimi elementami testowymi false, a w przeciwnym razie zwraca wartość false.

Uwagi

Funkcja szablonu zwraca true wartość tylko wtedy, gdy wszystkie elementy w elemercie [first, last) są partycjonowane przez predelement ; oznacza to, że wszystkie elementy X , w [first, last) których pred (X) występuje wartość true, przed wszystkimi elementami Y , dla których pred (Y) jest false.

`is_permutation`

Zwraca wartość true , jeśli oba zakresy zawierają te same elementy, niezależnie od tego, czy elementy są w tej samej kolejności. Użyj przeciążeń dwuzakresowych w kodzie C++14, ponieważ przeciążenia, które przyjmują tylko jeden iterator dla drugiego zakresu, nie będą wykrywać różnic, jeśli drugi zakres jest dłuższy niż pierwszy zakres. Te przeciążenia spowodują niezdefiniowane zachowanie, jeśli drugi zakres jest krótszy niż pierwszy zakres.

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
Iterator do przodu, który odwołuje się do pierwszego elementu zakresu.

last1
Iterator do przodu, który odwołuje się do jednego ostatniego elementu zakresu.

first2
Iterator do przodu, który odwołuje się do pierwszego elementu drugiego zakresu, używany do porównania.

last2
Iterator do przodu, który odwołuje się do jednego ostatniego elementu drugiego zakresu, używanego do porównania.

pred
Predykat, który testuje równoważność i zwraca boolwartość .

Wartość zwracana

true jeżeli zakresy można zmienić tak, aby było identyczne zgodnie z predykatem komparatora; w przeciwnym razie, false.

Uwagi

is_permutation ma kwadratową złożoność w najgorszym przypadku.

Pierwsza funkcja szablonu zakłada, że istnieje tyle elementów w zakresie rozpoczynającym się first2 od , jak w zakresie wyznaczonym przez [first1, last1)element . Jeśli w drugim zakresie znajduje się więcej elementów, są one ignorowane; jeśli jest mniej, wystąpi niezdefiniowane zachowanie. Trzecia funkcja szablonu (C++14 lub nowsza) nie przyjmuje tego założenia. Oba elementy zwracają true tylko wtedy, gdy dla każdego elementu X w zakresie wyznaczonym przez [first1, last1) element istnieje tyle elementów Y w tym samym zakresie, dla którego X == Y występuje w zakresie rozpoczynającym się od first2 lub [first2, last2). operator== W tym miejscu należy wykonać porównanie parowania między operandami.

Drugie i czwarte funkcje szablonu zachowują się tak samo, z tą różnicą, że zastępują element operator==(X, Y)Pred(X, Y). Aby zachowywać się poprawnie, predykat musi być symetryczny, refleksyjny i przechodni.

Przykład

W poniższym przykładzie pokazano, jak używać polecenia 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`

Zwraca wartość true , jeśli elementy w określonym zakresie są w kolejności sortowania.

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
Zasady wykonywania do użycia.

first
Iterator do przodu, który wskazuje, gdzie rozpoczyna się sprawdzanie zakresu.

last
Iterator do przodu wskazujący koniec zakresu.

pred
Warunek do przetestowania w celu określenia kolejności między dwoma elementami. Predykat porównania przyjmuje dwa argumenty i zwraca wartość true lub false. Ten predykat wykonuje to samo zadanie co operator<.

Uwagi

Pierwsza funkcja szablonu zwraca wartość is_sorted_until( first, last ) == last. Funkcja operator< wykonuje porównanie kolejności.

Druga funkcja szablonu zwraca wartość is_sorted_until( first, last , pred ) == last. Funkcja pred predykat wykonuje porównanie kolejności.

`is_sorted_until`

Zwraca element ForwardIterator , który jest ustawiony na ostatni element, który jest w kolejności posortowanej z określonego zakresu.

Druga wersja umożliwia podanie obiektu funkcji porównania, który zwraca true , gdy dwa podane elementy są w kolejności sortowania i false w przeciwnym razie.

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
Zasady wykonywania do użycia.

first
Iterator do przodu wskazujący, gdzie rozpoczyna się sprawdzanie zakresu.

last
Iterator do przodu wskazujący koniec zakresu.

pred
Warunek do przetestowania w celu określenia kolejności między dwoma elementami. Predykat porównania przyjmuje dwa argumenty i zwraca wartość true lub false.

Wartość zwracana

ForwardIterator Zwraca zestaw do ostatniego elementu w kolejności posortowanej. Sekwencja posortowana rozpoczyna się od .first

Uwagi

Pierwsza funkcja szablonu zwraca ostatni iterator next w [first, last] elemeracji, aby [first, next) była to sekwencja posortowana uporządkowana według operator<. Jeśli distance() wartość jest mniejsza niż 2, funkcja zwraca lastwartość .

Druga funkcja szablonu zachowuje się tak samo, z tą różnicą, że zastępuje operator<(X, Y)pred(X, Y)element .

`iter_swap`

Wymienia dwie wartości, do których odnosi się para określonych iteratorów.

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

Parametry

left
Jeden z iteratorów przesyłania dalej, którego wartość ma być wymieniana.

right
Druga iteratory przesyłania dalej, których wartość ma być wymieniana.

Uwagi

swap należy użyć preferencji, aby iter_swap, który został uwzględniony w standardzie C++ w celu zapewnienia zgodności z poprzednimi wersjami. Jeśli Fit1 i Fit2 są iteratory przesyłania dalej, to iter_swap( Fit1, Fit2 ), jest odpowiednikiem swap( *Fit1, *Fit2 ).

Typy wartości iteratorów przesyłania dalej danych wejściowych muszą mieć tę samą wartość.

Przykład

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

Porównuje dwie sekwencje element po elemencie, aby określić, która z nich jest mniejsza.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym zakresie do porównania.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym zakresie do porównania.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim zakresie do porównania.

last2
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w drugim zakresie do porównania.

Wartość zwracana

true jeśli pierwszy zakres jest leksykograficznie mniejszy niż drugi zakres; w przeciwnym razie false.

Uwagi

Porównanie leksykograficzne między sekwencjami porównuje je element według elementu do:

Znajduje dwa odpowiednie elementy nierówne, a wynik ich porównania jest traktowany jako wynik porównania między sekwencjami.
Nie znaleziono nierówności, ale jedna sekwencja ma więcej elementów niż druga, a krótsza sekwencja jest uważana za mniejszą niż dłuższa sekwencja.
Nie znaleziono nierówności, a sekwencje mają taką samą liczbę elementów, więc sekwencje są równe, a wynikiem porównania jest false.

Przykład

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

Znajduje pozycję pierwszego elementu w uporządkowanym zakresie, który ma wartość większą niż lub równoważną określonej wartości. Kryterium porządkowania może być określone przez predykat binarny.

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
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do przeszukania.

value
Wartość, której pierwsza pozycja lub ewentualna pierwsza pozycja jest wyszukiwana w uporządkowanym zakresie.

Wartość zwracana

Iterator do przodu na pozycji pierwszego elementu w uporządkowanym zakresie z wartością większą lub równoważną określonej wartości. Równoważność można określić z predykatem binarnym.

Uwagi

Posortowany zakres źródłowy, do których odwołuje się odwołanie, musi być prawidłowy; wszystkie iteratory muszą być wyłuszające, a w sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Posortowany zakres jest warunkiem wstępnym użycia lower_bound i gdzie kolejność jest taka sama jak w przypadku predykatu binarnego.

Zakres nie jest modyfikowany przez algorytm lower_bound.

Złożoność algorytmu jest logarytmiczna dla iteratorów dostępu losowego i liniowego w przeciwnym razie z liczbą kroków proporcjonalnych do (last - first).

Przykład

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

Konwertuje elementy z określonego zakresu na stertę, w której pierwszy element jest największy i dla której kryterium sortowania może być określone przez predykat binarny.

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
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w zakresie, który ma zostać przekonwertowany na stertę.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać przekonwertowany na stertę.

Uwagi

Stertki mają dwie właściwości:

Pierwszy element jest zawsze największy.
Elementy mogą być dodawane lub usuwane w czasie logarytmicznych.

Stery są idealnym sposobem implementowania kolejek priorytetowych i są one używane w implementacji adaptera kontenera biblioteki standardowej języka C++ priority_queue Class.

Złożoność jest liniowa, wymagając 3 * (last - first) porównań.

Przykład

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

Porównuje dwa obiekty i zwraca większy z nich, gdzie kryterium sortowania może być określone przez predykat binarny.

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
Pierwszy z dwóch porównywanych obiektów.

right
Drugi z dwóch porównywanych obiektów.

pred
Predykat binarny używany do porównywania dwóch obiektów.

inlist
Lista inicjatora zawierająca obiekty do porównania.

Wartość zwracana

Większe z dwóch obiektów, chyba że żadna z nich nie jest większa; w takim przypadku zwraca pierwszy z dwóch obiektów. Gdy element initializer_list zostanie określony, zwraca największą liczbę obiektów na liście.

Uwagi

Algorytm max jest nietypowy w przypadku przekazywania obiektów jako parametrów. Większość algorytmów biblioteki standardowej języka C++ działa na wielu elementach, których pozycja jest określana przez iteratory przekazywane jako parametry. Jeśli potrzebujesz funkcji, która działa na wielu elementach, użyj max_element zamiast tego. Program Visual Studio 2017 włącza constexpr przeciążenia, które przyjmują element initializer_list.

Przykład

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

Znajduje pierwsze wystąpienie największego elementu w określonym zakresie, gdzie kryterium sortowania może być określone przez predykat binarny.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do wyszukania największego elementu.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma być wyszukiwany dla największego elementu.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator do przodu odnoszący się do pozycji pierwszego wystąpienia największego elementu w wyszukiwanym zakresie.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszające, a w każdej sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność jest liniowa: (last - first) - 1 porównania są wymagane dla żadnego zakresu.

Przykład

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

Łączy wszystkie elementy z dwóch posortowanych zakresów źródłowych w jeden, posortowany zakres docelowy, gdzie kryterium porządkowania może być określone przez predykat binarny.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym z dwóch posortowanych zakresów źródłowych, które mają zostać połączone i posortowane w jeden zakres.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym z dwóch posortowanych zakresów źródłowych, które mają zostać połączone i posortowane w jeden zakres.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych, które mają być łączone i sortowane w jeden zakres.

last2
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych, które mają zostać połączone i posortowane w jeden zakres.

result
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie docelowym, w którym dwa zakresy źródłowe mają zostać połączone w jeden posortowany zakres.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w posortowanego zakresu docelowego.

Uwagi

Posortowane zakresy źródłowe, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w każdej sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Zakres docelowy nie powinien nakładać się na jeden z zakresów źródłowych i powinien być wystarczająco duży, aby zawierał zakres docelowy.

Posortowane zakresy źródłowe muszą być ułożone jako warunek wstępny do zastosowania algorytmu merge zgodnie z tą samą kolejnością, co ma być używane przez algorytm do sortowania połączonych zakresów.

Operacja jest stabilna, ponieważ względna kolejność elementów w każdym zakresie jest zachowywana w zakresie docelowym. Zakresy źródłowe nie są modyfikowane przez algorytm merge.

Złożoność algorytmu jest liniowa z co najwyżej (last1 - first1) - (last2 - first2) - 1 porównaniami.

Klasa list udostępnia funkcję merge składową do scalania elementów dwóch list.

Przykład

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

Porównuje dwa obiekty i zwraca mniejszy z nich, gdzie kryterium sortowania może być określone przez predykat binarny.

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
Pierwszy z dwóch porównywanych obiektów.

right
Drugi z dwóch porównywanych obiektów.

pred
Predykat binarny używany do porównywania dwóch obiektów.

inlist
Element initializer_list zawierający elementy członkowskie do porównania.

Wartość zwracana

Mniejsze z dwóch obiektów, chyba że żadna z nich nie jest mniejsza; w takim przypadku zwraca pierwszy z dwóch obiektów. Po określeniu elementu initializer_list zwraca najmniej obiektów na liście.

Uwagi

Algorytm min jest nietypowy w przypadku przekazywania obiektów jako parametrów. Większość algorytmów biblioteki standardowej języka C++ działa na wielu elementach, których pozycja jest określana przez iteratory przekazywane jako parametry. Jeśli potrzebujesz funkcji korzystającej z zakresu elementów, użyj polecenia min_element. constexpr włączono initializer_list przeciążenia w programie Visual Studio 2017.

Przykład

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

Znajduje pierwsze wystąpienie najmniejszego elementu w określonym zakresie, gdzie kryterium sortowania może być określone przez predykat binarny.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie, który ma być wyszukiwany dla najmniejszego elementu.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma być wyszukiwany dla najmniejszego elementu.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator do przodu odnoszący się do pozycji pierwszego wystąpienia najmniejszego elementu w wyszukiwanym zakresie.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszające, a w każdej sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność jest liniowa: (last - first) - 1 porównania są wymagane dla żadnego zakresu.

Przykład

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

Wykonuje pracę wykonywaną przez min_element polecenie i max_element w jednym wywołaniu.

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
Zasady wykonywania do użycia.

first
Iterator do przodu, który wskazuje początek zakresu.

last
Iterator do przodu wskazujący koniec zakresu.

pred
Obiekt funkcji predykatu zdefiniowany przez użytkownika, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy jest mniejszy niż drugi i false w przeciwnym razie.

Wartość zwracana

Zwroty

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

Uwagi

Pierwsza funkcja szablonu zwraca

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

Druga funkcja szablonu zachowuje się tak samo, z tą różnicą, że zastępuje operator<(X, Y)pred(X, Y)element .

Jeśli sekwencja nie jest pusta, funkcja wykonuje co najwyżej 3 * (last - first - 1) / 2 porównania.

`minmax`

Porównuje dwa parametry wejściowe i zwraca je jako parę w kolejności mniejszej do większej.

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
Pierwszy z dwóch porównywanych obiektów.

right
Drugi z dwóch porównywanych obiektów.

pred
Predykat binarny używany do porównywania dwóch obiektów.

inlist
Element initializer_list zawierający elementy członkowskie do porównania.

Uwagi

Pierwsza funkcja szablonu zwraca pair<const Type&, const Type&>( right, left ) wartość , jeśli right jest mniejsza niż left. W przeciwnym razie zwraca wartość pair<const Type&, const Type&>( left, right ).

Druga funkcja składowa zwraca parę, w której pierwszy element jest mniejszy, a drugi jest większy w porównaniu z predykatem pred.

Pozostałe funkcje szablonu zachowują się tak samo, z tą różnicą, że zastępują left parametry i right parametrami inlist.

Funkcja wykonuje dokładnie jedno porównanie.

`mismatch`

Porównuje dwa zakresy elementu według elementu i lokalizuje pierwszą pozycję, w której występuje różnica.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym zakresie do przetestowania.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym zakresie, który ma zostać przetestowany.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim zakresie do przetestowania.

last2
Iterator wejściowy odnoszący się do pozycji jednego ostatniego elementu w drugim zakresie do przetestowania.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który porównuje bieżące elementy w każdym zakresie i określa, czy są równoważne. Zwraca wartość true w przypadku zadowolenia i false braku zadowolenia.

Wartość zwracana

Zwraca parę iteratorów odnoszących się do pozycji niezgodności w dwóch zakresach. Pierwszy iterator składników wskazuje pozycję w pierwszym zakresie. Drugi iterator składników wskazuje pozycję w drugim zakresie. Jeśli nie ma różnicy między elementami w zakresach porównywanych lub jeśli predykat binarny w drugiej wersji jest spełniony przez wszystkie pary elementów z dwóch zakresów, to pierwszy iterator składnika wskazuje pozycję jedną obok ostatniego elementu w pierwszym zakresie i drugi iterator składników wskazuje pozycję jedną obok ostatniego elementu przetestowanego w drugim zakresie.

Uwagi

Pierwsza funkcja szablonu zakłada, że istnieje tyle elementów w zakresie, które zaczynają się od początku 2, ponieważ istnieją w zakresie wyznaczonym przez [first1, last1). Jeśli w drugim zakresie znajduje się więcej, są one ignorowane; Jeśli jest mniej, wówczas niezdefiniowane zachowanie będzie skutkować.

Zakres do przeszukania musi być prawidłowy; wszystkie iteratory muszą być wyłuszające, a ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność czasowa algorytmu jest liniowa w liczbie elementów zawartych w krótszym zakresie.

Predykat zdefiniowany przez użytkownika nie jest wymagany do nałożenia relacji równoważności, która jest symetryczna, refleksyjna i przechodnia między operandami.

Przykład

W poniższym przykładzie pokazano, jak używać niezgodności. Przeciążenie języka C++03 jest wyświetlane tylko w celu zademonstrowania, w jaki sposób może spowodować nieoczekiwany wynik.

#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`

Przenieś elementy związane z określonym zakresem.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący, gdzie rozpocząć zakres elementów do przeniesienia.

last
Iterator wejściowy wskazujący koniec zakresu elementów do przeniesienia.

dest
Iterator danych wyjściowych, który ma zawierać przeniesione elementy.

Uwagi

Funkcja szablonu oblicza *(dest + N) = move(*(first + N)) raz dla każdego N z nich w zakresie [0, last - first), w celu ścisłego zwiększania wartości rozpoczynających N się od najniższej wartości. Następnie zwraca wartość dest + N. Jeśli dest i first wyznaczyć regiony magazynu, dest nie może znajdować się w zakresie [first, last).

`move_backward`

Przenosi elementy jednego iteratora do drugiego. Przeniesienie rozpoczyna się od ostatniego elementu w określonym zakresie, a kończy się na pierwszym elemencie w tym zakresie.

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

Parametry

first
Iterator wskazujący początek zakresu, z którego mają być przenoszone elementy.

last
Iterator wskazujący koniec zakresu, z którego mają być przenoszone elementy. Ten element nie został przeniesiony.

destEnd
Iterator dwukierunkowy odnoszący się do pierwszej pozycji po elemencie końcowym w zakresie docelowym.

Uwagi

Funkcja szablonu oblicza *(destEnd - N - 1) = move(*(last - N - 1)) raz dla każdego N z nich w zakresie [0, last - first), w celu ścisłego zwiększania wartości rozpoczynających N się od najniższej wartości. Następnie zwraca wartość destEnd - (last - first). Jeśli destEnd i first wyznaczyć regiony magazynu, destEnd nie może znajdować się w zakresie [first, last).

move i move_backward są funkcjonalnie równoważne użyciu copy i copy_backward z iteratorem przenoszenia.

`next_permutation`

Zmienia kolejność elementów w zakresie, tak aby oryginalna kolejność została zastąpiona leksykograficznie następnym większym permutacją, jeśli istnieje. Sens leksykograficznie można określić z predykatem binarnym.

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
Iterator dwukierunkowy wskazujący pozycję pierwszego elementu w zakresie, który ma być permutowany.

last
Iterator dwukierunkowy wskazujący pozycję jedną obok ostatniego elementu w zakresie, który ma być permutowany.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje kryterium porównania, które ma być spełnione przez kolejne elementy w kolejności. Predykat binarny przyjmuje dwa argumenty i zwraca, true gdy jest spełniony, a false gdy nie jest spełniony.

Wartość zwracana

true jeżeli istnieje leksykograficznie następna permutacja i zastąpiła oryginalną kolejność zakresu; w przeciwnym razie false, w którym przypadku kolejność jest przekształcana w leksykograficznie najmniejszą permutację.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Domyślny predykat binarny jest mniejszy niż, a elementy w zakresie muszą być mniejsze niż porównywalne, aby upewnić się, że kolejna permutacja jest dobrze zdefiniowana.

Złożoność jest liniowa z co najwyżej (last - first) / 2 zamianami.

Przykład

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

Dzieli zakres elementów, poprawnie lokalizując nelement sekwencji w zakresie, który spełnia następujące kryteria: wszystkie elementy przed nim są mniejsze lub równe, a wszystkie obserwowane elementy są większe lub równe.

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
Zasady wykonywania do użycia.

first
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w zakresie do partycjonowania.

nth
Iterator dostępu losowego odnoszący się do położenia elementu, który ma być poprawnie uporządkowany na granicy partycji.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do partycjonowania.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje kryterium porównania, które ma być spełnione przez kolejne elementy w kolejności. Predykat porównania przyjmuje dwa argumenty i zwraca true , gdy jest spełniony i false gdy nie jest spełniony.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Algorytm nth_element nie gwarantuje, że elementy w podgrupach po obu stronach nelementu są sortowane. W ten sposób daje mniej gwarancji niż partial_sort, która porządkuje elementy w zakresie poniżej wybranego elementu i może być używana jako szybsza alternatywa dla partial_sort , gdy kolejność niższego zakresu nie jest wymagana.

Elementy są równoważne, ale niekoniecznie równe, jeśli żadna z nich nie jest mniejsza niż druga.

Średnia złożoności sortowania jest liniowa w odniesieniu do last - first.

Przykład

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

Zwraca wartość true , gdy warunek nigdy nie występuje wśród elementów w danym zakresie.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący, gdzie rozpocząć sprawdzanie zakresu elementów warunku.

last
Iterator wejściowy wskazujący koniec zakresu elementów.

pred
Warunek do przetestowania. Ten test jest dostarczany przez obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Zwraca wartość true , jeśli warunek nie zostanie wykryty co najmniej raz w wskazanym zakresie i false jeśli warunek zostanie wykryty.

Uwagi

Funkcja szablonu zwraca true tylko wtedy, gdy dla niektórych N w zakresie [0, last - first)predykat pred(*(first + N)) jest zawsze false.

`partial_sort`

Rozmieszcza określoną liczbę mniejszych elementów w zakresie w kolejność niezwiązaną. Predykat binarny może dostarczyć kryterium porządkowania.

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
Zasady wykonywania do użycia.

first
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w zakresie do sortowania.

sortEnd
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w podgrupie, który ma zostać posortowany.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma być częściowo posortowany.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Elementy są równoważne, ale niekoniecznie równe, jeśli żadna z nich nie jest mniejsza niż druga. sort Algorytm nie jest stabilny i nie gwarantuje zachowania względnej kolejności równoważnych elementów. Algorytm stable_sort zachowuje tę oryginalną kolejność.

Średnia złożoność sortowania częściowego to dziennik O((firstlast- ) (sortEnd- first)).

Przykład

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

Kopiuje elementy z zakresu źródłowego do zakresu docelowego, gdzie elementy źródłowe są uporządkowane według albo zasady mniejszy niż, albo innego określonego predykatu binarnego.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w zakresie źródłowym.

last1
Iterator danych wejściowych odnoszący się do pozycji jednej obok ostatniego elementu w zakresie źródłowym.

first2
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w posortowanego zakresu docelowego.

last2
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w posortowanego zakresu docelowego.

Wartość zwracana

Iterator dostępu losowego odnoszący się do elementu w zakresie docelowym o jednej pozycji poza ostatnim elementem wstawionym z zakresu źródłowego.

Uwagi

Zakresy źródłowe i docelowe nie mogą się nakładać i muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w każdej sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację.

Predykat binarny musi zapewnić ścisłe słabe porządkowanie, aby elementy, które nie są równoważne, zostały uporządkowane, ale elementy, które są równoważne, nie są. Dwa elementy są równoważne w ramach mniejszej niż, ale niekoniecznie równe, jeśli żadna z nich nie jest mniejsza niż druga.

Przykład

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

Klasyfikuje elementy w zakresie do dwóch rozłącznych zestawów, z tymi elementami spełniającymi predykat jednoargumentowy poprzedzający te, które nie spełniają tego celu.

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
Zasady wykonywania do użycia.

first
Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w zakresie do partycjonowania.

last
Iterator dwukierunkowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do partycjonowania.

pred
Obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek, który ma zostać spełniony, jeśli element ma zostać sklasyfikowany. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w zakresie, aby nie spełniał warunku predykatu.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Elementy a i b są równoważne, ale niekoniecznie równe, jeśli oba pred( a, b ) są fałszywe i pred( b, a ) są fałszywe, gdzie pred jest predykat określony parametrem. partition Algorytm nie jest stabilny i nie gwarantuje zachowania względnej kolejności równoważnych elementów. Algorytm stable_partition zachowuje tę oryginalną kolejność.

Złożoność jest liniowa: istnieją (last - first) zastosowania pred i w większości (last - first)/2 zamian.

Przykład

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

Kopiuje elementy, dla których warunek to true jedno miejsce docelowe, i dla którego warunek jest false inny. Elementy muszą pochodzić z określonego zakresu.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący początek zakresu w celu sprawdzenia warunku.

last
Iterator wejściowy wskazujący koniec zakresu.

dest1
Iterator danych wyjściowych używany do kopiowania elementów, które zwracają wartość true dla warunku przetestowanego przy użyciu polecenia pred.

dest2
Iterator danych wyjściowych używany do kopiowania elementów, które zwracają wartość false dla warunku przetestowanego przy użyciu polecenia pred.

pred
Warunek do przetestowania. Test jest dostarczany przez obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek do przetestowania. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Uwagi

Funkcja szablonu kopiuje każdy element X do [first,last)*dest1++ elementu , jeśli pred(X) ma wartość true, lub *dest2++ do , jeśli nie. Zwraca wartość pair<OutputIterator1, OutputIterator2>(dest1, dest2).

`partition_point`

Zwraca pierwszy element w danym zakresie, który nie spełnia warunku. Elementy są sortowane tak, aby te, które spełniają warunek, przyszedł przed tymi, które nie.

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

Parametry

first
Element ForwardIterator wskazujący początek zakresu w celu sprawdzenia warunku.

last
Element ForwardIterator wskazujący koniec zakresu.

pred
Warunek do przetestowania. Test jest dostarczany przez obiekt funkcji predykatu zdefiniowanego przez użytkownika, który definiuje warunek, który ma zostać spełniony przez wyszukiwany element. Predykat jednoargumentowy przyjmuje jeden argument i zwraca true wartość lub false.

Wartość zwracana

Zwraca element ForwardIterator , który odwołuje się do pierwszego elementu, który nie spełnia warunku przetestowanego przez predelement , lub zwraca last wartość , jeśli nie zostanie znaleziona.

Uwagi

Funkcja szablonu znajduje pierwszy iterator it , w [first, last) którym pred(*it) to false. Sekwencja musi być uporządkowana według pred.

`pop_heap`

Usuwa największy element z przodu sterty do przedostatniej pozycji w zakresie, a następnie tworzy nową stertę z pozostałych elementów.

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
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w stercie.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w stercie.

Uwagi

pop_heap Algorytm jest odwrotnością operacji wykonywanej przez algorytm push_heap, w którym element znajdujący się na następnej do ostatniej pozycji zakresu jest dodawany do sterta składającego się z poprzednich elementów w zakresie, w przypadku gdy element dodawany do sterty jest większy niż którykolwiek z elementów znajdujących się już w stercie.

Stertki mają dwie właściwości:

Pierwszy element jest zawsze największy.
Elementy mogą być dodawane lub usuwane w czasie logarytmicznych.

Stery są idealnym sposobem implementowania kolejek priorytetowych i są one używane w implementacji adaptera kontenera biblioteki standardowej języka C++ priority_queue Class.

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Zakres z wyłączeniem nowo dodanego elementu na końcu musi być stertą.

Złożoność jest logarytmiczna, wymagająca w większości log (last - first) porównań.

Przykład

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

Zmienia kolejność elementów w zakresie, tak aby oryginalna kolejność została zamieniona przez leksykograficznie poprzednią większą permutację, jeśli istnieje. Predykat binarny może określać sens leksykograficznie poprzedniego.

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
Iterator dwukierunkowy wskazujący pozycję pierwszego elementu w zakresie, który ma być permutowany.

last
Iterator dwukierunkowy wskazujący pozycję jedną obok ostatniego elementu w zakresie, który ma być permutowany.

Wartość zwracana

true jeżeli istnieje leksykograficznie poprzedni permutacja i zastąpiła oryginalną kolejność zakresu; w przeciwnym razie false, w którym przypadku kolejność jest przekształcana w leksykograficznie największą permutację.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Domyślny predykat binarny jest mniejszy niż, a elementy w zakresie muszą być mniej niż porównywalne, aby upewnić się, że poprzednia permutacja jest dobrze zdefiniowana.

Złożoność jest liniowa, z co najwyżej (last - first)/2 zamianami.

Przykład

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

Dodaje element znajdujący się na końcu zakresu do istniejącej sterty, która składa się z poprzednich elementów w zakresie.

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
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w stercie.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać przekonwertowany na stertę.

Uwagi

Najpierw element musi zostać odepchnięty z powrotem na koniec istniejącego sterta, a następnie algorytm jest używany do dodawania tego elementu do istniejącej sterty.

Stertki mają dwie właściwości:

Pierwszy element jest zawsze największy.
Elementy mogą być dodawane lub usuwane w czasie logarytmicznych.

Stery są idealnym sposobem implementowania kolejek priorytetowych i są one używane w implementacji adaptera kontenera biblioteki standardowej języka C++ priority_queue Class.

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Zakres z wyłączeniem nowo dodanego elementu na końcu musi być stertą.

Złożoność jest logarytmiczna, wymagająca w większości log(last - first) porównań.

Przykład

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

Funkcja std::random_shuffle() jest przestarzała, zastąpiona przez std::shuffle. Aby uzyskać przykład kodu i więcej informacji, zobacz <random> i wpis Stack Overflow Dlaczego metody są std::random_shuffle przestarzałe w języku C++14?.

`remove`

Eliminuje określoną wartość z danego zakresu bez zakłócania kolejności pozostałych elementów. Zwraca koniec nowego zakresu wolnego od określonej wartości.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie, z którego elementy są usuwane.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, z którego elementy są usuwane.

value
Wartość, która ma zostać usunięta z zakresu.

Wartość zwracana

Iterator do przodu odnoszący się do nowej pozycji końcowej zmodyfikowanego zakresu, jeden obok ostatniego elementu sekwencji resztek wolny od określonej wartości.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Kolejność elementów, które nie zostały usunięte, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. To sprawia, że (last - first) porównania równości.

Klasa list ma bardziej wydajną wersję funkcji składowej removeklasy , która również łączy wskaźniki.

Przykład

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

Kopiuje elementy z zakresu źródłowego do zakresu docelowego, z tą różnicą, że elementy określonej wartości nie są kopiowane, bez zakłócania kolejności pozostałych elementów. Zwraca koniec nowego zakresu docelowego.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do położenia pierwszego elementu w zakresie od którego są usuwane elementy.

last
Iterator danych wejściowych odnoszący się do położenia jednego obok ostatniego elementu w zakresie, z którego elementy są usuwane.

result
Iterator danych wyjściowych odnoszący się do położenia pierwszego elementu w zakresie docelowym, do którego są usuwane elementy.

value
Wartość, która ma zostać usunięta z zakresu.

Wartość zwracana

Iterator do przodu odnoszący się do nowej pozycji końcowej zakresu docelowego, po jednym obok ostatniego elementu kopii sekwencji resztek wolnej od określonej wartości.

Uwagi

Przywoływana liczba zakresów źródłowych i docelowych musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

W zakresie docelowym musi być wystarczająca ilość miejsca, aby zawierać elementy pozostałe, które zostaną skopiowane po usunięciu elementów określonej wartości.

Kolejność elementów, które nie zostały usunięte, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. Wykonuje () porównania równości i w większości przypisań (lastfirst - ).last - first

Przykład

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

Kopiuje elementy z zakresu źródłowego do zakresu docelowego, z wyjątkiem elementów spełniających predykat. Elementy są kopiowane bez zakłócania kolejności pozostałych elementów. Zwraca koniec nowego zakresu docelowego.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do położenia pierwszego elementu w zakresie od którego są usuwane elementy.

last
Iterator danych wejściowych odnoszący się do położenia jednego obok ostatniego elementu w zakresie, z którego elementy są usuwane.

result
Iterator danych wyjściowych odnoszący się do położenia pierwszego elementu w zakresie docelowym, do którego są usuwane elementy.

pred
Predykat jednoargumentowy, który musi być spełniony, to wartość elementu ma zostać zamieniona.

Wartość zwracana

Iterator do przodu odnoszący się do nowej pozycji końcowej zakresu docelowego, jeden obok ostatniego elementu sekwencji pozostałości wolny od elementów spełniających predykat.

Uwagi

Zakres źródłowy, do których odwołuje się odwołanie, musi być prawidłowy; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

W zakresie docelowym musi być wystarczająca ilość miejsca, aby zawierać elementy pozostałe, które zostaną skopiowane po usunięciu elementów określonej wartości.

Kolejność elementów, które nie zostały usunięte, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. Wykonuje () porównania równości i w większości przypisań (lastfirst - ).last - first

Aby uzyskać informacje na temat zachowania tych funkcji, zobacz Sprawdzone iteratory.

Przykład

// 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 elementy spełniające predykat z danego zakresu bez zakłócania kolejności pozostałych elementów. Zwraca koniec nowego zakresu wolnego od określonej wartości.

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
Zasady wykonywania do użycia.

first
Iterator do przodu wskazujący położenie pierwszego elementu w zakresie od którego są usuwane elementy.

last
Iterator do przodu wskazujący pozycję jedną obok ostatniego elementu w zakresie, z którego elementy są usuwane.

pred
Predykat jednoargumentowy, który musi być spełniony, to wartość elementu ma zostać zamieniona.

Wartość zwracana

Iterator do przodu odnoszący się do nowej pozycji końcowej zmodyfikowanego zakresu, jeden obok ostatniego elementu sekwencji resztek wolny od określonej wartości.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Kolejność elementów, które nie zostały usunięte, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. To sprawia, że (last - first) porównania równości.

Lista ma bardziej wydajną wersję funkcji składowej usuwania, które ponownie łączy wskaźniki.

Przykład

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

Sprawdza każdy element w zakresie i zastępuje go, jeśli odpowiada określonej wartości.

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
Zasady wykonywania do użycia.

first
Iterator do przodu wskazujący położenie pierwszego elementu w zakresie, z którego elementy są zastępowane.

last
Iterator do przodu wskazujący pozycję jedną obok ostatniego elementu w zakresie, z którego elementy są zastępowane.

oldVal
Stara wartość zastępowanych elementów.

newVal
Nowa wartość przypisana do elementów ze starą wartością.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Kolejność elementów, które nie zostały zastąpione, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. Tworzy (last - first) porównania równości i w większości (last - first) przypisań nowych wartości.

Przykład

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

Sprawdza każdy element w zakresie źródłowym i zastępuje go, jeśli odpowiada określonej wartości, jednocześnie kopiując wynik do nowego zakresu docelowego.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący położenie pierwszego elementu w zakresie, z którego elementy są zastępowane.

last
Iterator wejściowy wskazujący pozycję jedną obok ostatniego elementu w zakresie, z którego elementy są zastępowane.

result
Iterator danych wyjściowych wskazujący pierwszy element w zakresie docelowym, do którego jest kopiowana zmieniona sekwencja elementów.

oldVal
Stara wartość zastępowanych elementów.

newVal
Nowa wartość przypisana do elementów ze starą wartością.

Wartość zwracana

Iterator danych wyjściowych wskazujący pozycję jedną obok ostatniego elementu w zakresie docelowym, do którego jest kopiowana zmieniona sekwencja elementów.

Uwagi

Przywoływalne zakresy źródłowe i docelowe nie mogą się nakładać i muszą być prawidłowe: wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencjach ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Kolejność elementów, które nie zostały zastąpione, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. Tworzy (last - first) porównania równości i w większości (last - first) przypisań nowych wartości.

Przykład

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

Ze względu na wywołanie random_shuffle() w poprzednim kodzie dane wyjściowe mogą być inne.

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`

Sprawdza każdy element w zakresie źródłowym i zastępuje go, jeśli spełnia określony predykat, jednocześnie kopiując wynik do nowego zakresu docelowego.

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
Zasady wykonywania do użycia.

first
Iterator wejściowy wskazujący położenie pierwszego elementu w zakresie, z którego elementy są zastępowane.

last
Iterator wejściowy wskazujący pozycję jedną obok ostatniego elementu w zakresie, z którego elementy są zastępowane.

result
Iterator danych wyjściowych wskazujący położenie pierwszego elementu w zakresie docelowym, do którego są kopiowane elementy.

pred
Predykat jednoargumentowy, który musi być spełniony, to wartość elementu ma zostać zamieniona.

value
Nowa wartość przypisana do elementów, których stara wartość spełnia predykat.

Wartość zwracana

Iterator danych wyjściowych wskazujący pozycję jedną obok ostatniego elementu w zakresie docelowym, do którego jest kopiowana zmieniona sekwencja elementów.

Uwagi

Kolejność elementów, które nie zostały zastąpione, pozostaje stabilna.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. Tworzy (last - first) porównania równości i w większości (last - first) przypisań nowych wartości.

Przykład

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

Sprawdza każdy element w zakresie i zastępuje go, jeśli spełnia określony predykat.

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
Zasady wykonywania do użycia.

first
Iterator do przodu wskazujący położenie pierwszego elementu w zakresie, z którego elementy są zastępowane.

last
Iterator wskazujący pozycję jedną obok ostatniego elementu w zakresie, z którego elementy są zastępowane.

pred
Predykat jednoargumentowy, który musi być spełniony, to wartość elementu ma zostać zamieniona.

value
Nowa wartość przypisana do elementów, których stara wartość spełnia predykat.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Kolejność elementów, które nie zostały zastąpione, pozostaje stabilna.

Algorytm replace_if jest uogólnianie algorytmu replace, co umożliwia określenie dowolnego predykatu, a nie równości z określoną wartością stałą.

Używany operator== do określania równości między elementami musi narzucić relację równoważności między operandami.

Złożoność jest liniowa. Tworzy (last - first) porównania równości i w większości (last - first) przypisań nowych wartości.

Przykład

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

Odwraca kolejność elementów w obrębie zakresu.

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

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

Parametry

exec
Zasady wykonywania do użycia.

first
Iterator dwukierunkowy wskazujący położenie pierwszego elementu w zakresie, w którym elementy są permutowane.

last
Iterator dwukierunkowy wskazujący pozycję jedną obok ostatniego elementu w zakresie, w którym elementy są permutowane.

Uwagi

Przykład

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

Odwraca kolejność elementów w obrębie zakresu źródłowego, jednocześnie kopiując je do zakresu docelowego

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
Zasady wykonywania do użycia.

first
Iterator dwukierunkowy wskazujący położenie pierwszego elementu w zakresie źródłowym, w którym są permutowane elementy.

last
Iterator dwukierunkowy wskazujący pozycję jedną obok ostatniego elementu w zakresie źródłowym, w którym elementy są permutowane.

result
Iterator danych wyjściowych wskazujący położenie pierwszego elementu w zakresie docelowym, do którego są kopiowane elementy.

Wartość zwracana

Iterator danych wyjściowych wskazujący pozycję jedną obok ostatniego elementu w zakresie docelowym, do którego jest kopiowana zmieniona sekwencja elementów.

Uwagi

Przykład

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

Wymienia elementy znajdujące się w dwóch sąsiednich zakresach.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do położenia pierwszego elementu w zakresie, który ma zostać obrócony.

middle
Iterator do przodu definiujący granicę w zakresie, który odpowiada pozycji pierwszego elementu w drugiej części zakresu, którego elementy mają być wymieniane z tymi w pierwszej części zakresu.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać obrócony.

Uwagi

Zakresy, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność jest liniowa. To sprawia, że w większości (last - first) zamiany.

Przykład

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

Wymienia elementy w dwóch sąsiednich zakresach w ramach zakresu źródłowego i kopiuje wynik do zakresu docelowego.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do położenia pierwszego elementu w zakresie, który ma zostać obrócony.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać obrócony.

result
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie docelowym.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w zakresie docelowym.

Uwagi

Zakresy, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność jest liniowa. To sprawia, że w większości (last - first) zamiany.

Przykład

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

Wyszukuje pierwsze wystąpienie sekwencji w zakresie docelowym, którego elementy są równe elementom w danej sekwencji elementów lub których elementy są równoważne w sensie określonym przez predykat binarny do elementów w danej sekwencji.

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
Zasady wykonywania do użycia.

first1
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last1
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do przeszukania.

first2
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie, który ma być dopasowany.

last2
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma być dopasowany.

searcher
Wyszukiwanie, które hermetyzuje wzorzec do wyszukania, oraz algorytm wyszukiwania do użycia. Aby uzyskać więcej informacji na temat wyszukiwania, zobacz default_searcher klasa, boyer_moore_horspool_searcher klasa i boyer_moore_searcher klasa.

Wartość zwracana

Uwagi

Używany operator== do określania dopasowania między elementem a określoną wartością musi narzucić relację równoważności między operandami.

Średnia złożoność jest liniowa w odniesieniu do rozmiaru wyszukiwanego zakresu. Najgorsza złożoność przypadku jest również liniowa w odniesieniu do rozmiaru wyszukiwanej sekwencji.

Przykład

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

Wyszukuje pierwszą podsekwencję w zakresie, w której określona liczba elementów ma określoną wartość lub relację do tej wartości określoną przez predykat binarny.

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
Zasady wykonywania do użycia.

first1
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do przeszukania.

last1
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do przeszukania.

count
Rozmiar wyszukiwanego podsekwencjonowania.

value
Wartość elementów w wyszukiwanej sekwencji.

Wartość zwracana

Uwagi

Używany operator== do określania dopasowania między elementem a określoną wartością musi narzucić relację równoważności między operandami.

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność jest liniowa w odniesieniu do rozmiaru przeszukanego elementu.

Przykład

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

Łączy wszystkie elementy należące do jednego posortowanego zakresu źródłowego, ale nie do drugiego posortowanego zakresu źródłowego w jeden posortowany zakres docelowy. Predykat binarny może określać kryterium porządkowania.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym z dwóch posortowanych zakresów źródłowych, które mają być połączone i posortowane w jeden zakres reprezentujący różnicę dwóch zakresów źródłowych.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym z dwóch posortowanych zakresów źródłowych, które mają być połączone i posortowane w jeden zakres reprezentujący różnicę dwóch zakresów źródłowych.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych do zjednoczenia i posortowania w jednym zakresie reprezentującym różnicę dwóch zakresów źródłowych.

last2
Iterator wejściowy odnoszący się do pozycji jeden obok ostatniego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych, które mają być połączone i posortowane w jeden zakres reprezentujący różnicę dwóch zakresów źródłowych.

result
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie docelowym, w którym dwa zakresy źródłowe mają być połączone w jeden posortowany zakres reprezentujący różnicę dwóch zakresów źródłowych.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat binarny przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w posortowanego zakresu docelowego reprezentującego różnicę dwóch zakresów źródłowych.

Uwagi

Zakres docelowy nie powinien nakładać się na jeden z zakresów źródłowych i powinien być wystarczająco duży, aby zawierał pierwszy zakres źródłowy.

Posortowane zakresy źródłowe muszą być ułożone jako warunek wstępny do zastosowania algorytmu set_difference zgodnie z tą samą kolejnością, co ma być używane przez algorytm do sortowania połączonych zakresów.

Operacja jest stabilna, ponieważ względna kolejność elementów w każdym zakresie jest zachowywana w zakresie docelowym. Zakresy źródłowe nie są modyfikowane przez scalanie algorytmu.

Typy wartości iteratorów wejściowych muszą być mniej niż porównywalne do uporządkowanych. To znaczy, biorąc pod uwagę dwa elementy, można określić, że jeden jest mniejszy niż drugi, lub że są równoważne. (W tym przypadku odpowiednik oznacza, że żadna z nich nie jest mniejsza niż druga). To porównanie powoduje kolejność między elementami niekwentnych. Jeśli istnieją równoważne elementy w obu zakresach źródłowych, elementy w pierwszym zakresie poprzedzają elementy z drugiego zakresu źródłowego w zakresie docelowym. Jeśli zakresy źródłowe zawierają duplikaty elementu, tak aby w pierwszym zakresie źródłowym było więcej niż w drugim, zakres docelowy będzie zawierać liczbę, według której wystąpienia tych elementów w pierwszym zakresie źródłowym przekraczają wystąpienia tych elementów w drugim zakresie źródłowym.

Złożoność algorytmu jest liniowa z co najwyżej 2 * ((last1 - first1) + (last2 - first2)) - 1 porównaniami dla brakowych zakresów źródłowych.

Przykład

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

Łączy w sobie wszystkie elementy, które należą do obu posortowanych zakresów źródłowych w pojedynczy posortowany zakres docelowy, gdzie kryterium szeregowania może być określone przez predykat binarny.

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
Zasady wykonywania do użycia.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych, które mają być połączone i posortowane w jeden zakres reprezentujący przecięcie dwóch zakresów źródłowych.

last2
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych, które mają być połączone i posortowane w jeden zakres reprezentujący przecięcie dwóch zakresów źródłowych.

result
Iterator danych wyjściowych odnoszący się do położenia pierwszego elementu w zakresie docelowym, w którym dwa zakresy źródłowe mają być połączone w jeden posortowany zakres reprezentujący przecięcie dwóch zakresów źródłowych.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat binarny przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w posortowanego zakresu docelowego reprezentującego przecięcie dwóch zakresów źródłowych.

Uwagi

Zakres docelowy nie powinien nakładać się na jeden z zakresów źródłowych i powinien być wystarczająco duży, aby zawierał zakres docelowy.

Posortowane zakresy źródłowe muszą być ułożone jako warunek wstępny stosowania algorytmu scalania zgodnie z tą samą kolejnością, co ma być używane przez algorytm do sortowania połączonych zakresów.

Operacja jest stabilna, ponieważ względna kolejność elementów w każdym zakresie jest zachowywana w zakresie docelowym. Zakresy źródłowe nie są modyfikowane przez algorytm.

Typy wartości iteratorów wejściowych muszą być mniej niż porównywalne do uporządkowanych. To znaczy, biorąc pod uwagę dwa elementy, można określić, że jeden jest mniejszy niż drugi, lub że są równoważne. (W tym przypadku odpowiednik oznacza, że żadna z nich nie jest mniejsza niż druga). To porównanie powoduje kolejność między elementami niekwentnych. Jeśli istnieją równoważne elementy w obu zakresach źródłowych, elementy w pierwszym zakresie poprzedzają elementy z drugiego zakresu źródłowego w zakresie docelowym. Jeśli zakresy źródłowe zawierają duplikaty elementu, zakres docelowy będzie zawierać maksymalną liczbę tych elementów występujących w obu zakresach źródłowych.

Złożoność algorytmu jest liniowa z co najwyżej 2 * ((last1 - first1) + (last2 - first2)) - 1 porównaniami dla brakowych zakresów źródłowych.

Przykład

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

Łączy wszystkie elementy należące do jednego, ale nie obu posortowanych zakresów źródłowych w jeden, posortowany zakres docelowy. Predykat binarny może określać kryterium porządkowania.

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
Zasady wykonywania do użycia.

last2
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w drugim z dwóch kolejnych posortowanych zakresów źródłowych do zjednoczenia i posortowania w jednym zakresie reprezentującym symetryczną różnicę dwóch zakresów źródłowych.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat binarny przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w posortowanego zakresu docelowego reprezentującego symetryczną różnicę dwóch zakresów źródłowych.

Uwagi

Zakres docelowy nie powinien nakładać się na jeden z zakresów źródłowych i powinien być wystarczająco duży, aby zawierał zakres docelowy.

Posortowane zakresy źródłowe muszą być ułożone jako warunek wstępny do zastosowania algorytmu merge* zgodnie z tą samą kolejnością, co ma być używane przez algorytm do sortowania połączonych zakresów.

Operacja jest stabilna, ponieważ względna kolejność elementów w każdym zakresie jest zachowywana w zakresie docelowym. Zakresy źródłowe nie są modyfikowane przez scalanie algorytmu.

Typy wartości iteratorów wejściowych muszą być mniej niż porównywalne do uporządkowanych. To znaczy, biorąc pod uwagę dwa elementy, można określić, że jeden jest mniejszy niż drugi, lub że są równoważne. (W tym przypadku odpowiednik oznacza, że żadna z nich nie jest mniejsza niż druga). To porównanie powoduje kolejność między elementami niekwentnych. Jeśli istnieją równoważne elementy w obu zakresach źródłowych, elementy w pierwszym zakresie poprzedzają elementy z drugiego zakresu źródłowego w zakresie docelowym. Jeśli zakresy źródłowe zawierają duplikaty elementu, zakres docelowy będzie zawierać wartość bezwzględną liczby, za pomocą której wystąpienia tych elementów w jednym z zakresów źródłowych przekraczają wystąpienia tych elementów w drugim zakresie źródłowym.

Złożoność algorytmu jest liniowa z co najwyżej 2 * ((last1 - first1) + (last2 - first2)) - 1 porównaniami dla brakowych zakresów źródłowych.

Przykład

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

Łączy wszystkie elementy należące do co najmniej jednego z dwóch posortowanych zakresów źródłowych w jeden posortowany zakres docelowy. Predykat binarny może określać kryterium porządkowania.

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
Zasady wykonywania do użycia.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat binarny przyjmuje dwa argumenty i powinien zostać zwrócony true , gdy pierwszy element jest mniejszy niż drugi element i false w przeciwnym razie.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w posortowanego zakresu docelowego reprezentującego związek dwóch zakresów źródłowych.

Uwagi

Zakres docelowy nie powinien nakładać się na jeden z zakresów źródłowych i powinien być wystarczająco duży, aby zawierał zakres docelowy.

Operacja jest stabilna, ponieważ względna kolejność elementów w każdym zakresie jest zachowywana w zakresie docelowym. Zakresy źródłowe nie są modyfikowane przez algorytm merge.

Typy wartości iteratorów wejściowych muszą być mniej niż porównywalne do uporządkowanych. To znaczy, biorąc pod uwagę dwa elementy, można określić, że jeden jest mniejszy niż drugi, lub że są równoważne. (W tym przypadku odpowiednik oznacza, że żadna z nich nie jest mniejsza niż druga). To porównanie powoduje kolejność między elementami niekwentnych. Jeśli istnieją równoważne elementy w obu zakresach źródłowych, elementy w pierwszym zakresie poprzedzają elementy z drugiego zakresu źródłowego w zakresie docelowym. Jeśli zakresy źródłowe zawierają duplikaty elementu, zakres docelowy będzie zawierać maksymalną liczbę tych elementów występujących w obu zakresach źródłowych.

Złożoność algorytmu jest liniowa z co najwyżej 2 * ((last1 - first1) + (last2 - first2)) - 1 porównaniami.

Przykład

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

Elementy mieszania (rozmieszczania) dla danego zakresu przy użyciu generatora liczb losowych.

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

Parametry

first
Iterator do pierwszego elementu w zakresie, który ma być mieszany, włącznie. Musi spełniać wymagania RandomAccessIterator i ValueSwappable.

last
Iterator do ostatniego elementu w zakresie, który ma być mieszany, wyłączny. Musi spełniać wymagania RandomAccessIterator i ValueSwappable.

gen
Generator liczb losowych, który shuffle() będzie używany przez funkcję dla operacji. Musi spełniać wymagania obiektu UniformRandomNumberGenerator.

Uwagi

Aby uzyskać więcej informacji i przykładowy kod korzystający z shuffle()programu , zobacz <random>.

`sort`

Rozmieszcza elementy w określonym zakresie w niemalejącej kolejności lub według kryteriów sortowania określonych przez binarny predykat.

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
Zasady wykonywania do użycia.

first
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w zakresie do sortowania.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać posortowany.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje kryterium porównania, które ma być spełnione przez kolejne elementy w kolejności. Ten predykat binarny przyjmuje dwa argumenty i zwraca, true jeśli dwa argumenty są w kolejności i false w przeciwnym razie. Ta funkcja komparatora musi nakładać ścisłe słabe kolejność na pary elementów z sekwencji. Aby uzyskać więcej informacji, zobacz Algorytmy.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Średnia złożoności sortowania to O( N log N ), gdzie N = last - first.

Przykład

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

Konwertuje stertę na sortowany zakres.

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
Iterator dostępu losowego odnoszący się do pozycji pierwszego elementu w stercie docelowej.

last
Iterator dostępu losowego odnoszący się do pozycji jednej obok ostatniego elementu w stercie docelowej.

Uwagi

Stertki mają dwie właściwości:

Pierwszy element jest zawsze największy.
Elementy mogą być dodawane lub usuwane w czasie logarytmicznych.

Po zastosowaniu tego algorytmu zakres, do którego został zastosowany, nie jest już stertą.

sort_heap nie jest stabilnym sortowaniem, ponieważ względna kolejność równoważnych elementów nie musi być zachowywana.

Stery są idealnym sposobem implementowania kolejek priorytetowych i są używane w implementacji klasy kontenera priority_queue biblioteki standardowej języka C++.

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność to co najwyżej N log N, gdzie N = last - first.

Przykład

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

Klasyfikuje elementy w zakresie do dwóch rozłącznych zestawów, z elementami, które spełniają predykat jednoargumentowy poprzedzający te, które nie spełniają go, zachowując względną kolejność równoważnych elementów.

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
Zasady wykonywania do użycia.

first
Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w zakresie do partycjonowania.

last
Iterator dwukierunkowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do partycjonowania.

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w zakresie, aby nie spełniał warunku predykatu.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Elementy a i b są równoważne, ale niekoniecznie równe, jeśli oba pred( a, b ) są fałszywe i pred( b, a ) są fałszywe, gdzie pred jest predykat określony parametrem. stable_partition Algorytm jest stabilny i gwarantuje zachowanie względnej kolejności równoważnych elementów. Algorytm partition nie musi zachowywać oryginalnej kolejności.

Przykład

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

Rozmieszcza elementy w określonym zakresie w niemalejącej kolejności lub według kryteriów sortowania określonych przez binarny predykat. Zachowuje względną kolejność elementów równoważnych.

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
Zasady wykonywania do użycia.

first
Iterator dwukierunkowy odnoszący się do pozycji pierwszego elementu w zakresie do sortowania.

last
Iterator dwukierunkowy odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać posortowany.

Uwagi

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Elementy są równoważne, ale niekoniecznie równe, jeśli żadna z nich nie jest mniejsza niż druga. sort Algorytm jest stabilny i gwarantuje zachowanie względnej kolejności równoważnych elementów.

Złożoność stable_sort czasu wykonywania zależy od ilości dostępnej pamięci, ale najlepszym przypadkiem (biorąc pod uwagę wystarczającą ilość pamięci) jest O(N log N) i najgorszy przypadek to O(N (log N)^2), gdzie N = last - first. sort Zazwyczaj algorytm jest szybszy niż stable_sort.

Przykład

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

Pierwsza przesłonięć wymienia wartości dwóch obiektów. Drugi przesłonięć wymienia wartości między dwiema tablicami obiektów.

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
Pierwszy przesłonięć pierwszy obiekt, który ma wymienić jego zawartość. W przypadku drugiego przesłonięcia pierwsza tablica obiektów, która ma wymieniać jego zawartość.

right
W przypadku pierwszego przesłonięcia drugi obiekt, który ma wymienić jego zawartość. W przypadku drugiego przesłonięcia druga tablica obiektów, która ma wymieniać jego zawartość.

Uwagi

Pierwsze przeciążenie zostało zaprojektowane tak, aby działało na poszczególnych obiektach. Drugie przeciążenie zamienia zawartość obiektów między dwiema tablicami.

Przykład

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

Zamienia elementy jednego zakresu przez elementy innego zakresu, zakresy mają równe wielkości.

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
Zasady wykonywania do użycia.

first1
Iterator do przodu wskazujący pierwszą pozycję pierwszego zakresu, którego elementy mają być wymieniane.

last1
Iterator do przodu wskazujący jedną obok końcowej pozycji pierwszego zakresu, którego elementy mają być wymieniane.

first2
Iterator do przodu wskazujący pierwszą pozycję drugiego zakresu, którego elementy mają być wymieniane.

Wartość zwracana

Iterator do przodu wskazujący jedną obok ostatniej pozycji drugiego zakresu, którego elementy mają być wymieniane.

Uwagi

Złożoność jest liniowa z wykonanymi zamianami last1 - first1. Jeśli elementy z kontenerów tego samego typu są zamieniane, należy ich swap używać funkcji składowej z tego kontenera, ponieważ funkcja składowa zwykle ma stałą złożoność.

Przykład

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

Stosuje określony obiekt funkcji do każdego elementu w zakresie źródłowym lub do pary elementów z dwóch zakresów źródłowych. Następnie kopiuje zwracane wartości obiektu funkcji do zakresu docelowego.

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
Zasady wykonywania do użycia.

first1
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w pierwszym zakresie źródłowym do działania.

last1
Iterator wejściowy odnoszący się do pozycji jednej obok ostatniego elementu w pierwszym zakresie źródłowym do działania.

first2
Iterator wejściowy odnoszący się do pozycji pierwszego elementu w drugim zakresie źródłowym do działania.

result
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie docelowym.

func
Zdefiniowany przez użytkownika obiekt funkcji jednoargumentowej używany w pierwszej wersji algorytmu do zastosowania do każdego elementu w pierwszym zakresie źródłowym lub obiektu funkcji binarnej zdefiniowanej przez użytkownika (UD) używanego w drugiej wersji algorytmu stosowanego w kolejności do przodu do dwóch zakresów źródłowych.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w zakresie docelowym, który odbiera elementy wyjściowe przekształcone przez obiekt funkcji.

Uwagi

Zakresy, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w każdej sekwencji ostatnia pozycja musi być osiągalna od pierwszego przez inkrementację. Zakres docelowy musi być wystarczająco duży, aby zawierał przekształcony zakres źródłowy.

Jeśli wynik jest ustawiony na first1 wartość równą w pierwszej wersji algorytmu, zakresy źródłowe i docelowe będą takie same, a sekwencja zostanie zmodyfikowana. Ale parametr result może nie być adresem pozycji w zakresie [first1 + 1, last1).

Złożoność jest liniowa. Co najwyżejlast1 - first1 () porównuje.

Przykład

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

Usuwa zduplikowane elementy, które znajdują się obok siebie w określonym zakresie.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie do skanowania w celu usunięcia duplikatów.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie do skanowania w celu usunięcia duplikatu.

Wartość zwracana

Iterator do przodu na nowym końcu zmodyfikowanej sekwencji, która nie zawiera kolejnych duplikatów, zwracając się do pozycji jednej obok ostatniego elementu, który nie został usunięty.

Uwagi

Obie formy algorytmu usuwają drugi duplikat kolejnej pary równych elementów.

Działanie algorytmu jest stabilne, aby względna kolejność nieukończonych elementów nie została zmieniona.

Przywoływana zakres musi być prawidłowa; wszystkie wskaźniki muszą być wyłuszczalne, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost. Liczba elementów w sekwencji nie jest zmieniana przez algorytm unique , a elementy poza końcem zmodyfikowanej sekwencji są wyłuszczone, ale nie są określone.

Złożoność jest liniowa, wymagając (last - first) - 1 porównań.

Lista zapewnia wydajniejszą funkcję składową "unique", która może działać lepiej.

Tych algorytmów nie można używać w kontenerze asocjacyjnym.

Przykład

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

Kopiuje elementy z zakresu źródłowego do zakresu docelowego z wyjątkiem zduplikowanych elementów, które znajdują się obok siebie.

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
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pozycji pierwszego elementu w zakresie źródłowym, który ma zostać skopiowany.

last
Iterator do przodu odnoszący się do pozycji jednej obok ostatniego elementu w zakresie źródłowym, który ma zostać skopiowany.

result
Iterator danych wyjściowych odnoszący się do pozycji pierwszego elementu w zakresie docelowym, który otrzymuje kopię z kolejnymi duplikatami usuniętymi.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do pozycji jednej obok ostatniego elementu w zakresie docelowym, który otrzymuje kopię z kolejnymi duplikatami usuniętymi.

Uwagi

Obie formy algorytmu usuwają drugi duplikat kolejnej pary równych elementów.

Działanie algorytmu jest stabilne, aby względna kolejność nieukończonych elementów nie została zmieniona.

Zakresy, do których odwołuje się odwołanie, muszą być prawidłowe; wszystkie wskaźniki muszą być wyłuszające, a w sekwencji ostatnia pozycja jest osiągalna od pierwszego przez przyrost.

Złożoność jest liniowa i wymaga porównania (last - first).

Przykład

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

Znajduje pozycję pierwszego elementu w uporządkowanym zakresie, który ma wartość większą niż określona wartość. Predykat binarny określa kryterium porządkowania.

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
Pozycja pierwszego elementu w zakresie do wyszukania.

last
Pozycja obok ostatniego elementu w zakresie do wyszukania.

value
Wartość w uporządkowanym zakresie, który musi zostać przekroczony przez wartość elementu adresowanego przez iterator zwrócony.

pred
Zdefiniowany przez użytkownika obiekt funkcji predykatu porównania, który definiuje sens, w którym jeden element jest mniejszy niż inny. Predykat porównania przyjmuje dwa argumenty i zwraca true , gdy jest spełniony i false gdy nie jest spełniony.

Wartość zwracana

Iterator do przodu do pozycji pierwszego elementu, który ma wartość większą niż określona wartość.

Uwagi

Posortowany zakres jest warunkiem wstępnym użycia upper_bound i gdzie kryterium porządkowania jest takie samo jak określone przez predykat porównania.

Zakres nie jest modyfikowany przez element upper_bound.

Złożoność algorytmu jest logarytmiczna dla iteratorów dostępu losowego i liniowego w przeciwnym razie z liczbą kroków proporcjonalnych do (last - first).

Przykład

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

<algorithm>, funkcje

adjacent_find

Parametry

Wartość zwracana

Uwagi

Przykład

all_of

Parametry

Wartość zwracana

Uwagi

Przykład

any_of

Parametry

Wartość zwracana

Uwagi

Przykład

binary_search

Parametry

Wartość zwracana

Uwagi

Przykład

clamp

Parametry

Wartość zwracana

Uwagi

copy

Parametry

Wartość zwracana

Uwagi

Przykład

copy_backward

Parametry

Wartość zwracana

Uwagi

Przykład

copy_if

Parametry

Wartość zwracana

Uwagi

Przykład

copy_n

Parametry

Wartość zwracana

Uwagi

Przykład

count

Parametry

Wartość zwracana

Uwagi

Przykład

count_if

Parametry

Wartość zwracana

Uwagi

Przykład

equal

Parametry

Wartość zwracana

Uwagi

Przykład

equal_range

Parametry

Wartość zwracana

Uwagi

Przykład

fill

Parametry

Uwagi

Przykład

fill_n

Parametry

Wartość zwracana

Uwagi

Przykład

find

Parametry

Wartość zwracana

Uwagi

find_end

Parametry

`<algorithm>`, funkcje

`adjacent_find`

`all_of`

`any_of`

`binary_search`

`clamp`

`copy`

`copy_backward`

`copy_if`

`copy_n`

`count`

`count_if`

`equal`

`equal_range`

`fill`

`fill_n`

`find`

`find_end`

`find_first_of`

`find_if`

`find_if_not`

`for_each`

`for_each_n`

`generate`

`generate_n`

`includes`

`inplace_merge`

`is_permutation`

`is_sorted`

`is_sorted_until`

`iter_swap`