<algorithm> functies

De <algorithm> header biedt de volgende functies:

adjacent_find

Zoekt naar twee aangrenzende elementen die gelijk zijn aan of voldoen aan een opgegeven voorwaarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuurserver op de positie van het eerste element in het bereik dat moet worden doorzocht.

last
Een doorstuur iterator op de positie één voorbij het laatste element in het bereik dat moet worden doorzocht.

pred
Het binaire predicaat dat de voorwaarde geeft waaraan moet worden voldaan door de waarden van de aangrenzende elementen in het bereik dat wordt doorzocht.

Retourwaarde

Een doorstuur iterator naar de eerste van de aangrenzende elementen die gelijk zijn aan elkaar (in de eerste versie) of die voldoen aan de voorwaarde die is opgegeven door het binaire predicaat (in de tweede versie) als een dergelijk paar elementen wordt gevonden. Anders wordt een iterator geretourneerd last die verwijst.

Opmerkingen

Het adjacent_find algoritme is een niet-muterend sequentie-algoritme. Het bereik dat moet worden doorzocht, moet geldig zijn. Alle aanwijzers moeten deductiebaar zijn en de laatste positie moet bereikbaar zijn vanaf de eerste door incrementatie. De tijdcomplexiteit van het algoritme is lineair in het aantal elementen in het bereik.

De operator== methode die wordt gebruikt om de overeenkomst tussen elementen te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

Voorbeeld

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

Retourneert true wanneer een voorwaarde aanwezig is op elk element in het opgegeven bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die aangeeft waar moet worden gecontroleerd op een voorwaarde. De iterator markeert waar een reeks elementen begint.

last
Een invoer-iterator die het einde van het bereik van elementen aangeeft om te controleren op een voorwaarde.

pred
Een voorwaarde om op te testen. pred is een door de gebruiker gedefinieerd unaire predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan door een element dat wordt gecontroleerd. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Retourneert true of de voorwaarde wordt gedetecteerd op elk element in het aangegeven bereik of als het bereik leeg is en false anderszins.

Opmerkingen

De sjabloonfunctie retourneert true alleen als, voor elk N in het bereik [0, last - first), het predicaat pred(*(first + N)) is true.

Voorbeeld

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

Retourneert true wanneer een voorwaarde ten minste eenmaal aanwezig is in het opgegeven bereik van elementen.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die aangeeft waar een bereik van elementen voor een voorwaarde moet worden gecontroleerd.

last
Een invoer-iterator die het einde van het bereik van elementen aangeeft om te controleren op een voorwaarde.

pred
Een voorwaarde om op te testen. Deze test wordt geleverd door een door de gebruiker gedefinieerd predicaatfunctieobject. Het predicaat definieert de voorwaarde waaraan moet worden voldaan door het element dat wordt getest. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Retourneert true als de voorwaarde ten minste één keer wordt gedetecteerd in het aangegeven bereik, false als de voorwaarde nooit wordt gedetecteerd.

Opmerkingen

De sjabloonfunctie retourneert true alleen als, voor sommige N in het bereik

[0, last - first), is het predicaat pred(*(first + N)) waar.

Voorbeeld

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

Hiermee wordt getest of er een element in een gesorteerd bereik is dat gelijk is aan een opgegeven waarde of dat gelijk is aan het element in een zin die is opgegeven door een binair predicaat.

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

Parameterwaarden

first
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

value
De waarde die moet worden vergeleken met de waarde van het element of die moet voldoen aan de voorwaarde met de elementwaarde die is opgegeven door het binaire predicaat.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

true als een element wordt gevonden in het bereik dat gelijk is aan of gelijk is aan de opgegeven waarde; anders, false.

Opmerkingen

Het gesorteerde bronbereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en, binnen de reeks, moet de laatste positie bereikbaar zijn vanaf de eerste met incrementatie.

Het gesorteerde bereik moet elk worden gerangschikt als voorwaarde voor de toepassing van het binary_search algoritme in overeenstemming met dezelfde volgorde als die door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren.

De bronbereiken worden niet gewijzigd door binary_search.

De waardetypen van de doorstuurservers moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen.

De complexiteit van het algoritme is logaritmisch voor iterators voor willekeurige toegang en lineair, met het aantal stappen proportioneel aan (last-first).

Voorbeeld

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

Vergelijkt een waarde met een boven- en ondergrens en retourneert een verwijzing naar de waarde als deze zich tussen de grenzen bevindt, of een verwijzing naar de boven- of ondergrens als de waarde er boven of onder ligt.

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

Parameterwaarden

value
De waarde die moet worden vergeleken met upper en lower.

lower
De ondergrens van de waarden waarop moet worden geklemd value .

upper
De bovengrens van de waarden waarop moet worden geklemd value .

pred
Een predicaat dat wordt gebruikt om te vergelijken value met lower of upper. Een vergelijkingspredicaat heeft twee argumenten en retourneert true als de eerste in zekere zin kleiner is dan de tweede, en anders. false

Retourwaarde

Retourneert een verwijzing naar lower if value < lower, of een verwijzing naar upper if upper < value. Anders wordt een verwijzing naar value.

Opmerkingen

Het gedrag is niet gedefinieerd als upper deze kleiner is dan lower.

copy

Hiermee worden de waarden van elementen uit een bronbereik toegewezen aan een doelbereik, waarbij de bronvolgorde van elementen wordt doorlopen en nieuwe posities in een voorwaartse richting worden toegewezen.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die de positie van het eerste element in het bronbereik aanpakt.

last
Een invoer-iterator die de positie aangeeft die zich achter het laatste element in het bronbereik bevindt.

destBeg
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aanpakt.

Retourwaarde

Een uitvoer-iterator die de positie aangeeft die zich achter het laatste element in het doelbereik bevindt, dat wil gezegd, de iteratoradressen result + ( - lastfirst).

Opmerkingen

Het bronbereik moet geldig zijn en er moet voldoende ruimte zijn op de bestemming om alle elementen te bewaren die worden gekopieerd.

Omdat het algoritme de bronelementen in volgorde kopieert vanaf het eerste element, kan het doelbereik overlappen met het bronbereik, mits de last positie van het bronbereik niet in het doelbereik is opgenomen. copy kan worden gebruikt om elementen naar links te verplaatsen, maar niet naar rechts, tenzij er geen overlap is tussen de bron- en doelbereiken. Gebruik het copy_backward algoritme om naar het juiste aantal posities te gaan.

Het copy algoritme wijzigt alleen waarden die worden verwezen door de iterators, waarbij nieuwe waarden worden toegewezen aan elementen in het doelbereik. Het kan niet worden gebruikt om nieuwe elementen te maken en kan geen elementen rechtstreeks in een lege container invoegen.

Voorbeeld

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

Wijst de waarden van elementen uit een bronbereik toe aan een doelbereik, doorloopt de bronvolgorde van elementen en wijst deze nieuwe posities toe in een achterwaartse richting.

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

Parameterwaarden

first
Een bidirectionele iterator die de positie van het eerste element in het bronbereik aanpakt.

last
Een bidirectionele iterator die de positie aangeeft die één voorbij het laatste element in het bronbereik ligt.

destEnd
Een bidirectionele iterator die de positie van één voorbij het laatste element in het doelbereik aanpakt.

Retourwaarde

Een uitvoer-iterator die de positie aangeeft die zich achter het laatste element in het doelbereik bevindt, dat wil gezegd, de iteratoradressen destEnd - (last - first).

Opmerkingen

Het bronbereik moet geldig zijn en er moet voldoende ruimte zijn op de bestemming om alle elementen te bewaren die worden gekopieerd.

Het copy_backward algoritme legt strengere vereisten op dan het copy algoritme. Zowel de invoer- als uitvoer-iterators moeten bidirectioneel zijn.

De copy_backward en move_backward algoritmen zijn de enige C++ Standard Library-algoritmen die het uitvoerbereik aanwijzen met een iterator die verwijst naar het einde van het doelbereik.

Omdat het algoritme de bronelementen kopieert op volgorde van het laatste element, kan het doelbereik overlappen met het bronbereik, mits de first positie van het bronbereik niet in het doelbereik is opgenomen. copy_backward kan worden gebruikt om elementen naar rechts te verplaatsen, maar niet naar links, tenzij er geen overlap is tussen de bron- en doelbereiken. Als u naar links een willekeurig aantal posities wilt gaan, gebruikt u het copy algoritme.

Het copy_backward algoritme wijzigt alleen waarden die worden verwezen door de iterators, waarbij nieuwe waarden worden toegewezen aan elementen in het doelbereik. Het kan niet worden gebruikt om nieuwe elementen te maken en kan geen elementen rechtstreeks in een lege container invoegen.

Voorbeeld

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

Kopieert in een bereik van elementen de elementen die voor de opgegeven voorwaarde zijn true .

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die het begin van een bereik aangeeft om te controleren op de voorwaarde.

last
Een invoer-iterator die het einde van het bereik aangeeft.

dest
De uitvoer-iterator die de bestemming voor de gekopieerde elementen aangeeft.

pred
De voorwaarde waarmee elk element in het bereik wordt getest. Deze voorwaarde wordt geleverd door een door de gebruiker gedefinieerd predicaatfunctieobject. Een unary predicaat heeft één argument en retourneert true of false.

Retourwaarde

Een uitvoer-iterator die eenmaal is dest verhoogd voor elk element dat aan de voorwaarde voldoet. Met andere woorden, de retourwaarde min dest is gelijk aan het aantal gekopieerde elementen.

Opmerkingen

De sjabloonfunctie evalueert

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

eenmaal voor elk N in het bereik [0, last - first), voor strikt toenemende waarden van N beginnen met de laagste waarde. Als dest en first regio's van opslag aanwijzen, dest mag deze zich niet in het bereik bevinden [ first, last ).

Voorbeeld

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

Hiermee kopieert u een opgegeven aantal elementen.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die aangeeft waar elementen vandaan moeten worden gekopieerd.

count
Een ondertekend of niet-ondertekend geheel getal dat het aantal elementen aangeeft dat moet worden gekopieerd.

dest
Een uitvoer-iterator die aangeeft waar elementen naartoe moeten worden gekopieerd.

Retourwaarde

Retourneert een uitvoer-iterator waarnaar elementen zijn gekopieerd. Dit is hetzelfde als de geretourneerde waarde van de dest parameter.

Opmerkingen

De sjabloonfunctie evalueert *(dest + N) = *(first + N)) één keer voor elk N in het bereik [0, count), om strikt toenemende waarden te N beginnen met de laagste waarde. Vervolgens wordt het geretourneerd dest + N. Als dest en first regio's van opslag aanwijzen, dest mag deze zich niet in het bereik bevinden [first, last).

Voorbeeld

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

Retourneert het aantal elementen in een bereik waarvan de waarden overeenkomen met een opgegeven waarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die de positie van het eerste element in het bereik aangeeft dat moet worden doorkruist.

last
Een invoer-iterator die de positie één voorbij het laatste element in het bereik heeft om door te gaan.

value
De waarde van de elementen die moeten worden geteld.

Retourwaarde

Het verschiltype van de InputIterator waarde die het aantal elementen in het bereik [first, last) telt value.

Opmerkingen

De operator== gebruikt om de overeenkomst tussen een element en de opgegeven waarde te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

Dit algoritme wordt gegeneraliseerd om elementen te tellen die voldoen aan een predicaat met de sjabloonfunctie count_if.

Voorbeeld

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

Retourneert het aantal elementen in een bereik waarvan de waarden voldoen aan een opgegeven voorwaarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die de positie van het eerste element in het bereik aanpakt dat moet worden doorzocht.

last
Een invoer-iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als een element moet worden geteld. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Het aantal elementen dat voldoet aan de voorwaarde die is opgegeven door het predicaat.

Opmerkingen

Deze sjabloonfunctie is een generalisatie van het algoritme count, waarbij het predicaat 'is gelijk aan een specifieke waarde' wordt vervangen door een predicaat.

Voorbeeld

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

Vergelijkt twee bereiken element per element voor gelijkheid of gelijkwaardigheid in een zin die is opgegeven door een binair predicaat.

Gebruik std::equal deze functie bij het vergelijken van elementen in verschillende containertypen (bijvoorbeeld vector en list) of bij het vergelijken van verschillende elementtypen, of wanneer u subbereiken van containers moet vergelijken. Als u andere elementen van hetzelfde type in hetzelfde containertype vergelijkt, gebruikt u het niet-lid operator== dat voor elke container is opgegeven.

Gebruik de overbelastingen met twee bereiken in C++14-code omdat de overbelastingen die slechts één iterator voor het tweede bereik nemen, geen verschillen detecteren als het tweede bereik langer is dan het eerste bereik. Deze overbelastingen leiden tot niet-gedefinieerd gedrag als het tweede bereik korter is dan het eerste bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in het eerste bereik aanpakt dat moet worden getest.

last1
Een invoer-iterator die de positie na het laatste element in het eerste bereik aangeeft dat moet worden getest.

first2
Een invoer-iterator die de positie van het eerste element in het tweede bereik aanpakt dat moet worden getest.

last2
Een invoer-iterator die de positie van één voorbij het laatste element in het tweede bereik aangeeft dat moet worden getest.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

true indien en alleen als de bereiken identiek of gelijkwaardig zijn onder het binaire predicaat wanneer het element per element wordt vergeleken; anders, false.

Opmerkingen

Het bereik dat moet worden doorzocht, moet geldig zijn; alle iterators moeten deductiebaar zijn en de laatste positie is bereikbaar vanaf de eerste door incrementatie.

Als de twee bereiken even lang zijn, is de tijdcomplexiteit van het algoritme lineair in het aantal elementen in het bereik. Anders retourneert falsede functie onmiddellijk .

U hebt geen van operator== beide of het door de gebruiker gedefinieerde predicaat nodig om een gelijkwaardigheidsrelatie op te leggen die symmetrisch, reflexief en transitief is tussen de operanden.

Voorbeeld

#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

Met een geordende bereik wordt de subbereik gevonden waarin alle elementen gelijk zijn aan een bepaalde waarde.

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

Parameterwaarden

first
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

value
De waarde die wordt gezocht in het geordende bereik.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Een vergelijkingspredicaat heeft twee argumenten en retourneert true wanneer er wordt voldaan en false wanneer niet is voldaan.

Retourwaarde

Een paar doorstuur iterators die een subbereik opgeven dat zich in het doorzochte bereik bevindt, waarin alle elementen gelijk zijn aan value in de zin die is gedefinieerd door het binaire predicaat dat wordt gebruikt ( pred of de standaardwaarde, kleiner dan).

Als er geen elementen in het bereik gelijk zijn aan value, zijn de doorstuurservers in het geretourneerde paar gelijk en geeft u het punt op waar value kan worden ingevoegd zonder de volgorde van het bereik te storen.

Opmerkingen

De eerste iterator van het paar dat door het algoritme wordt geretourneerd, is lower_bound, en de tweede iterator is upper_bound.

Het bereik moet worden gesorteerd op basis van het predicaat dat is opgegeven aan equal_range. Als u bijvoorbeeld het predicaat groter dan wilt gebruiken, moet het bereik in aflopende volgorde worden gesorteerd.

Elementen in het mogelijk lege subbereik dat is gedefinieerd door het paar iterators dat wordt equal_range geretourneerd, zijn gelijk aan de waarde in de zin die is gedefinieerd door het gebruikte predicaat.

De complexiteit van het algoritme is logaritmisch voor iterators voor willekeurige toegang en lineair, met het aantal stappen proportioneel aan (last - first).

Voorbeeld

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

Wijst dezelfde nieuwe waarde toe aan elk element in een opgegeven bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuurserver die de positie van het eerste element in het bereik aangeeft dat moet worden doorkruist.

last
Een doorstuur iterator die de positie voorbij het laatste element in het bereik heeft om te worden doorkruist.

value
De waarde die moet worden toegewezen aan elementen in het bereik [first, last).

Opmerkingen

Het doelbereik moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en de laatste positie is bereikbaar vanaf de eerste door incrementatie. De complexiteit is lineair met de grootte van het bereik.

Voorbeeld

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

Hiermee wordt een nieuwe waarde toegewezen aan een opgegeven aantal elementen in een bereik dat begint met een bepaald element.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een uitvoer-iterator die de positie van het eerste element in het bereik aangeeft waaraan de waarde valuemoet worden toegewezen.

count
Een ondertekend of niet-ondertekend geheel getal dat het aantal elementen aangeeft waaraan de waarde moet worden toegewezen.

value
De waarde die moet worden toegewezen aan elementen in het bereik [first, first + count).

Retourwaarde

Een iterator naar het element dat volgt op het laatste element dat is gevuld als count> nul, anders het eerste element.

Opmerkingen

Het doelbereik moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en de laatste positie is bereikbaar vanaf de eerste door incrementatie. De complexiteit is lineair met de grootte van het bereik.

Voorbeeld

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

Zoekt de positie van het eerste exemplaar van een element in een bereik met een opgegeven waarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die de positie van het eerste element in het bereik adresseren om naar de opgegeven waarde te zoeken.

last
Een invoer-iterator die de positie na het laatste element in het bereik adresseren om naar de opgegeven waarde te zoeken.

value
De waarde die moet worden gezocht.

Retourwaarde

Een invoer-iterator voor het eerste exemplaar van de opgegeven waarde in het bereik dat wordt doorzocht. Als er geen element met een equivalente waarde wordt gevonden, wordt geretourneerd last.

Opmerkingen

De operator== gebruikt om de overeenkomst tussen een element en de opgegeven waarde te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

Zie voor een codevoorbeeld dat u gebruiktfind()find_if.

find_end

Zoekt in een bereik naar de laatste subsequence die identiek is aan een opgegeven reeks of die equivalent is in een zin die is opgegeven door een binair predicaat.

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

Parameterwaarden

first1
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last1
Een doorstuur iterator die de positie na het laatste element in het bereik om te doorzoeken heeft.

first2
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren om naar te zoeken.

last2
Een doorstuur iterator die de positie na het laatste element in het bereik om naar te zoeken heeft.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een doorstuur iterator die de positie van het eerste element van de laatste subsequence binnen [eerste1, laatste1) aanpakt die overeenkomt met de opgegeven reeks [eerste2, laatste2).

Opmerkingen

De operator== gebruikt om de overeenkomst tussen een element en de opgegeven waarde te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde is de laatste positie bereikbaar vanaf de eerste door incrementatie.

Voorbeeld

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

Hiermee wordt gezocht naar het eerste exemplaar van een van de verschillende waarden binnen een doelbereik. Of zoekt naar het eerste exemplaar van een van de verschillende elementen die gelijkwaardig zijn in een zin die is opgegeven door een binair predicaat naar een opgegeven set van de elementen.

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

Parameterwaarden

first1
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last1
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

first2
Een doorstuur iterator die de positie van het eerste element in het bereik aanspreekt dat moet worden vergeleken.

last2
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te worden vergeleken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een doorstuur iterator die de positie van het eerste element van de eerste subsequence aanpakt die overeenkomt met de opgegeven reeks of die gelijkwaardig is in een zin die is opgegeven door een binair predicaat.

Opmerkingen

De operator== gebruikt om de overeenkomst tussen een element en de opgegeven waarde te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde is de laatste positie bereikbaar vanaf de eerste door incrementatie.

Voorbeeld

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

Zoekt de positie van het eerste exemplaar van een element in een bereik dat voldoet aan een opgegeven voorwaarde.

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

Parameterwaarden

first
Een invoer-iterator die de positie van het eerste element in het bereik aanpakt dat moet worden doorzocht.

last
Een invoer-iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject of lambda-expressie waarmee de voorwaarde wordt gedefinieerd waaraan moet worden voldaan door het element waarnaar wordt gezocht. Een unaire predicaat neemt één argument en retourneert true indien tevreden, of false niet tevreden. De handtekening van pred moet effectief zijn bool pred(const T& arg);, waarbij T een type is waarnaar InputIterator impliciet kan worden geconverteerd wanneer deductie wordt afgedwongen. Het const trefwoord wordt alleen weergegeven om aan te geven dat het functieobject of lambda het argument niet mag wijzigen.

Retourwaarde

Een invoer-iterator die verwijst naar het eerste element in het bereik dat voldoet aan de voorwaarde die is opgegeven door het predicaat (het predicaat resulteert in true). Als er geen element wordt gevonden om aan het predicaat te voldoen, wordt het resultaat geretourneerd last.

Opmerkingen

Deze sjabloonfunctie is een generalisatie van het algoritme find, waarbij het predicaat 'is gelijk aan een specifieke waarde' wordt vervangen door een predicaat. Zie voor het logische tegenovergestelde (zoek het eerste element dat niet aan het predicaat voldoet).find_if_not

Voorbeeld

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

Retourneert het eerste element in het aangegeven bereik dat niet voldoet aan een voorwaarde.

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

Parameterwaarden

first
Een invoer-iterator die de positie van het eerste element in het bereik aanpakt dat moet worden doorzocht.

last
Een invoer-iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject of lambda-expressie waarmee de voorwaarde wordt gedefinieerd waaraan niet wordt voldaan door het element waarnaar wordt gezocht. Een unaire predicaat neemt één argument en retourneert true indien tevreden, of false niet tevreden. De handtekening van pred moet effectief zijn bool pred(const T& arg);, waarbij T een type is waarnaar InputIterator impliciet kan worden geconverteerd wanneer deductie wordt afgedwongen. Het const trefwoord wordt alleen weergegeven om aan te geven dat het functieobject of lambda het argument niet mag wijzigen.

Retourwaarde

Een invoer-iterator die verwijst naar het eerste element in het bereik dat niet voldoet aan de voorwaarde die is opgegeven door het predicaat (het predicaat resulteert in false). Als alle elementen voldoen aan het predicaat (het predicaat resulteert voor true elk element), wordt geretourneerd last.

Opmerkingen

Deze sjabloonfunctie is een generalisatie van het algoritme find, waarbij het predicaat 'is gelijk aan een specifieke waarde' wordt vervangen door een predicaat. Zie voor het logische tegenovergestelde (zoek het eerste element dat voldoet aan het predicaat), zie find_if.

Zie voor een codevoorbeeld dat gemakkelijk kan worden aangepast aan find_if_not()find_if.

for_each

Hiermee wordt een opgegeven functieobject toegepast op elk element in een doorstuurvolgorde binnen een bereik en wordt het functieobject geretourneerd.

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

Parameterwaarden

first
Een invoer-iterator die de positie van het eerste element in het bereik aangeeft waarop moet worden gewerkt.

last
Een invoer-iterator die de positie na het laatste element in het bereik aangeeft.

func
Door de gebruiker gedefinieerd functieobject dat wordt toegepast op elk element in het bereik.

Retourwaarde

Een kopie van het functieobject nadat het is toegepast op alle elementen in het bereik.

Opmerkingen

Het algoritme for_each is flexibel, waardoor elk element binnen een bereik op verschillende, door de gebruiker opgegeven manieren kan worden gewijzigd. Templatized functies kunnen opnieuw worden gebruikt in een gewijzigde vorm door verschillende parameters door te geven. Door de gebruiker gedefinieerde functies kunnen informatie verzamelen binnen een interne status die het algoritme kan retourneren nadat alle elementen in het bereik zijn verwerkt.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en, binnen de reeks, moet de laatste positie bereikbaar zijn vanaf de eerste met incrementatie.

De complexiteit is lineair met maximaal (last - first) vergelijkingen.

Voorbeeld

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

Hiermee past u een opgegeven functieobject toe op een opgegeven aantal elementen in een bereik dat begint met een bepaald element.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator op de positie van het eerste element in het bereik waarop moet worden gewerkt.

count
Het aantal elementen waarop moet worden gewerkt.

func
Een door de gebruiker gedefinieerd functieobject dat moet worden toegepast op elk element in het bereik [first, first + count).

Retourwaarde

Een iterator voor het element dat volgt op het laatste element dat wordt verwerkt als count> nul, anders het eerste element.

Opmerkingen

count moet niet-negatief zijn en er moeten ten minste count elementen in het bereik zijn die beginnen vanaf first.

Voorbeeld

In dit voorbeeld wordt een functieobjectklasse gedefinieerd. Productiecode maakt vaak gebruik van een lambda om hetzelfde resultaat te bereiken met minder code.

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

Hiermee worden de waarden die door een functieobject worden gegenereerd, toegewezen aan elk element in een bereik.

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

Parameterwaarden

first
Een doorstuur iterator op de positie van het eerste element in het bereik waaraan waarden moeten worden toegewezen.

last
Een doorstuur iterator op de positie die zich achter het laatste element in het bereik bevindt waaraan waarden moeten worden toegewezen.

gen
Een functieobject dat zonder argumenten wordt aangeroepen om de waarden te genereren die aan elk van de elementen in het bereik moeten worden toegewezen.

Opmerkingen

Het functieobject wordt aangeroepen voor elk element in het bereik en hoeft niet telkens dezelfde waarde te retourneren wanneer het wordt aangeroepen. Het kan bijvoorbeeld lezen uit een bestand of verwijzen naar en wijzigen van een lokale status. Het resultaattype van de generator moet worden omgezet in het waardetype van de doorstuur iterator voor het bereik.

Het bereik waarnaar wordt verwezen, moet geldig zijn. Alle aanwijzers moeten deductiebaar zijn en binnen de reeks moet de laatste positie bereikbaar zijn vanaf de eerste met incrementatie.

De complexiteit is lineair, met exact last - first aanroepen naar de generator.

Voorbeeld

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

Hiermee worden de waarden die door een functieobject worden gegenereerd, toegewezen aan een opgegeven aantal elementen in een bereik. Retourneert de positie één voorbij de laatst toegewezen waarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een uitvoer-iterator die de positie van het eerste element in het bereik aangeeft waaraan waarden moeten worden toegewezen.

count
Een ondertekend of niet-ondertekend geheel getal dat het aantal elementen aangeeft dat aan de generatorfunctie moet worden toegewezen.

gen
Een functieobject dat wordt aangeroepen zonder argumenten die worden gebruikt om de waarden te genereren die aan elk van de elementen in het bereik moeten worden toegewezen.

Opmerkingen

Het functieobject wordt aangeroepen voor elk element in het bereik en hoeft niet telkens dezelfde waarde te retourneren wanneer het wordt aangeroepen. Het kan bijvoorbeeld lezen uit een bestand of verwijzen naar en wijzigen van een lokale status. Het resultaattype van de generator moet worden geconverteerd naar het waardetype van de doorstuurservers voor het bereik.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en, binnen de reeks, moet de laatste positie bereikbaar zijn vanaf de eerste met incrementatie.

De complexiteit is lineair, waarbij de generator precies count wordt aanroepen.

Voorbeeld

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

Hiermee wordt getest of één gesorteerd bereik alle elementen bevat die zijn opgenomen in een tweede gesorteerd bereik, waarbij het rangorde- of gelijkwaardigheidscriterium tussen elementen kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in de eerste van twee gesorteerde bronbereiken aanpakt om te testen of alle elementen van de tweede zijn opgenomen in de eerste.

last1
Een invoer-iterator die de positie na het laatste element in de eerste van twee gesorteerde bronbereiken aanpakt om te testen of alle elementen van de tweede zijn opgenomen in de eerste.

first2
Een invoer-iterator die de positie van het eerste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt om te testen of alle elementen van de tweede zijn opgenomen in de eerste.

last2
Een invoer-iterator die de positie na het laatste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt om te testen of alle elementen van de tweede in de eerste zijn opgenomen.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een vergelijkingspredicaat heeft twee argumenten en retourneert true wanneer er wordt voldaan en false wanneer niet is voldaan.

Retourwaarde

true als het eerste gesorteerde bereik alle elementen in het tweede gesorteerde bereik bevat; anders, false.

Opmerkingen

Een andere manier om aan deze test te denken, is dat wordt bepaald of het tweede bronbereik een subset van het eerste bronbereik is.

De gesorteerde bronbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste met incrementatie.

Als voorwaarde voor de toepassing van het algoritme includesmoeten de gesorteerde bronbereiken allemaal worden gerangschikt met dezelfde volgorde die door het algoritme wordt gebruikt om de gecombineerde bereiken te sorteren.

De bronbereiken worden niet gewijzigd door het algoritme merge.

De waardetypen van de invoer-iterators moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen. Het algoritme test precies of alle elementen in het eerste gesorteerde bereik onder een opgegeven binair predicaat equivalent zijn aan de elementen in het tweede gesorteerde bereik.

De complexiteit van het algoritme is lineair met op de meeste 2 * ((last1 - first1) + (last2 - first2)) - 1 vergelijkingen voor lege bronbereiken.

Voorbeeld

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

Combineert de elementen van twee opeenvolgende gesorteerde bereiken in één gesorteerd bereik, waarbij het rangordecriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een bidirectionele iterator die de positie van het eerste element in de eerste van twee opeenvolgende gesorteerde bereiken aanpakt die in één bereik moeten worden gecombineerd en gesorteerd.

middle
Een bidirectionele iterator die de positie van het eerste element in de tweede van twee opeenvolgende gesorteerde bereiken aanpakt die in één bereik moeten worden gecombineerd en gesorteerd.

last
Een bidirectionele iterator die de positie één voorbij het laatste element in de tweede van twee opeenvolgende gesorteerde bereiken aanpakt die in één bereik moet worden gecombineerd en gesorteerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het vergelijkingspredicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Opmerkingen

De gesorteerde opeenvolgende bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste met incrementatie.

De gesorteerde opeenvolgende bereiken moeten elk worden gerangschikt als voorwaarde voor de toepassing van het inplace_merge algoritme in overeenstemming met dezelfde volgorde als het algoritme dat door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren. De bewerking is stabiel omdat de relatieve volgorde van elementen binnen elk bereik behouden blijft. Wanneer er equivalente elementen in beide bronbereiken zijn, wordt het eerste bereik voorafgegaan door het element van de tweede in het gecombineerde bereik.

De complexiteit is afhankelijk van het beschikbare geheugen, omdat het algoritme geheugen toewijst aan een tijdelijke buffer. Als er voldoende geheugen beschikbaar is, is het beste geval lineair met (last - first) - 1 vergelijkingen; als er geen hulpgeheugen beschikbaar is, is N log(N)het slechtste geval , waarbij - Nlast = first .

Voorbeeld

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

Retourneert true als de elementen in het opgegeven bereik een heap vormen.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een iterator voor willekeurige toegang die het begin van een bereik aangeeft om te controleren op een heap.

last
Een iterator voor willekeurige toegang die het einde van een bereik aangeeft.

pred
Een voorwaarde die moet worden getest om elementen te orden. Een vergelijkingspredicaat heeft twee argumenten en retourneert true of false.

Retourwaarde

Retourneert true als de elementen in het opgegeven bereik een heap vormen, false als ze dat niet doen.

Opmerkingen

De eerste sjabloonfunctie retourneert is_heap_until(first , last) == last.

De tweede sjabloonfunctie retourneert

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

is_heap_until

Hiermee wordt een iterator geretourneerd die is op het eerste element in het bereik [ first, last) dat niet voldoet aan de heapvolgorde, of end als het bereik een heap vormt.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een iterator voor willekeurige toegang waarmee het eerste element van een bereik wordt opgegeven om te controleren op een heap.

last
Een iterator voor willekeurige toegang die het einde van het bereik aangeeft om te controleren op een heap.

pred
Een binair predicaat dat de strikte zwakke ordevoorwaarde aangeeft die een heap definieert. Het standaardpredicaat is std::less<> wanneer pred niet is opgegeven.

Retourwaarde

Retourneert last als het opgegeven bereik een heap vormt of een of minder elementen bevat. Anders wordt een iterator geretourneerd voor het eerste element dat niet voldoet aan de heap-voorwaarde.

Opmerkingen

De eerste sjabloonfunctie retourneert de laatste iterator next waarin [first, next)[first, last) een heap is gerangschikt door het functieobjectstd::less<>. Als de afstand last - first kleiner is dan 2, retourneert lastde functie .

De tweede sjabloonfunctie gedraagt zich hetzelfde als de eerste, behalve dat het predicaat pred wordt gebruikt in plaats van std::less<> als de heapvolgordevoorwaarde.

is_partitioned

Retourneert true als alle elementen in het opgegeven bereik die voor een voorwaarde worden getest true , vóór alle elementen die worden getest 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);

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die aangeeft waar een bereik begint te controleren op een voorwaarde.

last
Een invoer-iterator die het einde van een bereik aangeeft.

pred
De voorwaarde om op te testen. Deze test wordt geleverd door een door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan door het element waarnaar wordt gezocht. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Retourneert true wanneer alle elementen in het opgegeven bereik die testen true voor een voorwaarde vóór alle elementen die worden getest falseen anders, worden geretourneerd false.

Opmerkingen

De sjabloonfunctie retourneert true alleen als alle elementen [first, last) zijn gepartitioneerd door pred; dat wil gezegd, alle elementen [first, last)X waarvan pred (X) waar is, plaatsvinden voordat alle elementen Y hiervoor pred (Y)falsezijn.

is_permutation

Retourneert true als beide bereiken dezelfde elementen bevatten, ongeacht of de elementen in dezelfde volgorde staan. Gebruik de overbelastingen met twee bereiken in C++14-code omdat de overbelastingen die slechts één iterator voor het tweede bereik nemen, geen verschillen detecteren als het tweede bereik langer is dan het eerste bereik. Deze overbelastingen leiden tot niet-gedefinieerd gedrag als het tweede bereik korter is dan het eerste bereik.

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

Parameterwaarden

first1
Een doorstuur iterator die verwijst naar het eerste element van het bereik.

last1
Een doorstuur-iterator die één na het laatste element van het bereik verwijst.

first2
Een doorstuur iterator die verwijst naar het eerste element van een tweede bereik, dat wordt gebruikt voor vergelijking.

last2
Een doorstuur iterator die verwijst naar een na het laatste element van een tweede bereik, dat wordt gebruikt voor vergelijking.

pred
Een predicaat dat op gelijkwaardigheid test en een bool.

Retourwaarde

true wanneer de bereiken opnieuw kunnen worden gerangschikt, zodat deze identiek zijn volgens het predicaat van de comparator; anders, false.

Opmerkingen

is_permutation heeft kwadratische complexiteit in het ergste geval.

Bij de eerste sjabloonfunctie wordt ervan uitgegaan dat er net zoveel elementen in het bereik staan dat begint bij first2 het bereik dat is aangewezen door [first1, last1). Als er meer elementen in het tweede bereik zijn, worden ze genegeerd; als er minder, niet-gedefinieerd gedrag optreedt. De derde sjabloonfunctie (C++14 en hoger) maakt deze aanname niet. Beide retourneren true alleen als, voor elk element X in het bereik dat is aangewezen door [first1, last1) er zoveel elementen Y in hetzelfde bereik zijn waarvan X == Y het bereik begint bij first2 of [first2, last2). operator== Hier moet u een paarsgewijze vergelijking tussen de operanden uitvoeren.

De tweede en vierde sjabloonfuncties gedragen zich hetzelfde, behalve dat ze vervangen door operator==(X, Y)Pred(X, Y). Om zich correct te gedragen, moet het predicaat symmetrisch, reflexief en transitief zijn.

Voorbeeld

In het volgende voorbeeld ziet u hoe u is_permutationgebruikt:

#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

Retourneert true als de elementen in het opgegeven bereik in gesorteerde volgorde staan.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur-iterator die aangeeft waar het bereik moet worden gecontroleerd.

last
Een doorstuur iterator die het einde van een bereik aangeeft.

pred
De voorwaarde die moet worden getest om een volgorde tussen twee elementen te bepalen. Een vergelijkingspredicaat heeft twee argumenten en retourneert true of false. Met dit predicaat wordt dezelfde taak uitgevoerd als operator<.

Opmerkingen

De eerste sjabloonfunctie retourneert is_sorted_until( first, last ) == last. De operator< functie voert de volgordevergelijking uit.

De tweede sjabloonfunctie retourneert is_sorted_until( first, last , pred ) == last. De pred predicaatfunctie voert de volgordevergelijking uit.

is_sorted_until

Hiermee wordt een ForwardIterator waarde geretourneerd die is ingesteld op het laatste element in de gesorteerde volgorde van een opgegeven bereik.

Met de tweede versie kunt u een vergelijkingsfunctieobject opgeven dat retourneert true wanneer twee opgegeven elementen in gesorteerde volgorde staan en false anders.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuurserver die aangeeft waar het bereik moet worden gecontroleerd.

last
Een doorstuur iterator die het einde van een bereik aangeeft.

pred
De voorwaarde die moet worden getest om een volgorde tussen twee elementen te bepalen. Een vergelijkingspredicaat heeft twee argumenten en retourneert true of false.

Retourwaarde

Retourneert een ForwardIterator set op het laatste element in gesorteerde volgorde. De gesorteerde volgorde begint vanaf first.

Opmerkingen

De eerste sjabloonfunctie retourneert de laatste iteratornext, zodat dit [first, next) een gesorteerde volgorde is die is geordend opoperator<[first, last]. Als distance() deze kleiner is dan 2, retourneert lastde functie .

De tweede sjabloonfunctie gedraagt zich hetzelfde, behalve dat deze wordt vervangen door operator<(X, Y)pred(X, Y).

iter_swap

Hiermee worden twee waarden uitgewisseld waarnaar wordt verwezen door een paar opgegeven iterators.

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

Parameterwaarden

left
Een van de doorstuur iterators waarvan de waarde moet worden uitgewisseld.

right
De tweede van de doorstuurservers waarvan de waarde moet worden uitgewisseld.

Opmerkingen

swap moet worden gebruikt in voorkeur voor iter_swap, die is opgenomen in de C++-standaard voor achterwaartse compatibiliteit. Als Fit1 en Fit2 iterators zijn, is dit iter_swap( Fit1, Fit2 )gelijk aan swap( *Fit1, *Fit2 ).

De waardetypen van de doorstuurservers moeten dezelfde waarde hebben.

Voorbeeld

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

Vergelijkt element per element tussen twee reeksen om te bepalen welke minder van de twee is.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in het eerste bereik aanpakt dat moet worden vergeleken.

last1
Een invoer-iterator die de positie na het laatste element in het eerste bereik aangeeft dat moet worden vergeleken.

first2
Een invoer-iterator die de positie van het eerste element in het tweede bereik aanpakt dat moet worden vergeleken.

last2
Een invoer-iterator die de positie één voorbij het laatste element in het tweede bereik aanpakt dat moet worden vergeleken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een vergelijkingspredicaat heeft twee argumenten en retourneert true wanneer er wordt voldaan en false wanneer niet is voldaan.

Retourwaarde

true als het eerste bereik lexicografisch kleiner is dan het tweede bereik; anders false.

Opmerkingen

Een lexicografische vergelijking tussen reeksen vergelijkt het element per element tot:

• Er worden twee overeenkomende elementen ongelijk gevonden en het resultaat van hun vergelijking wordt genomen als resultaat van de vergelijking tussen reeksen.

• Er worden geen ongelijkvallen gevonden, maar één reeks heeft meer elementen dan de andere, en de kortere volgorde wordt als minder beschouwd dan de langere reeks.

• Er worden geen ongelijken gevonden en de reeksen hebben hetzelfde aantal elementen, dus de reeksen zijn gelijk en het resultaat van de vergelijking is false.

Voorbeeld

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

Hiermee zoekt u de positie van het eerste element in een geordende bereik met een waarde die groter is dan of gelijk is aan een opgegeven waarde. Het bestelcriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

first
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

value
De waarde waarvan de eerste positie of mogelijke eerste positie wordt gezocht in het geordende bereik.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een doorstuur-iterator op de positie van het eerste element in een geordende bereik met een waarde die groter is dan of gelijk is aan een opgegeven waarde. De gelijkwaardigheid kan worden opgegeven met een binair predicaat.

Opmerkingen

Het gesorteerde bronbereik waarnaar wordt verwezen, moet geldig zijn; alle iterators moeten deducteerbaar zijn en binnen de volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Een gesorteerd bereik is een voorwaarde voor het gebruik lower_bound en waarbij de volgorde hetzelfde is als opgegeven door met binair predicaat.

Het bereik wordt niet gewijzigd door het algoritme lower_bound.

De waardetypen van de doorstuurservers moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen.

De complexiteit van het algoritme is logaritmisch voor iterators voor willekeurige toegang en lineair, met het aantal stappen proportioneel aan (last - first).

Voorbeeld

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

Converteert elementen van een opgegeven bereik naar een heap waarin het eerste element het grootste element is en waarvoor een sorteercriterium kan worden opgegeven met een binair predicaat.

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

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

Parameterwaarden

first
Een iterator voor willekeurige toegang heeft betrekking op de positie van het eerste element in het bereik dat moet worden geconverteerd naar een heap.

last
Een iterator voor willekeurige toegang die de positie voorbij het laatste element in het bereik heeft om te worden omgezet in een heap.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Opmerkingen

Heaps hebben twee eigenschappen:

• Het eerste element is altijd de grootste.

• Elementen kunnen in logaritmische tijd worden toegevoegd of verwijderd.

Heaps zijn een ideale manier om prioriteitswachtrijen te implementeren en ze worden gebruikt in de implementatie van de C++ Standard Library-containeradapter priority_queue Klasse.

De complexiteit is lineair, waarvoor vergelijkingen nodig zijn 3 * (last - first) .

Voorbeeld

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

Vergelijkt twee objecten en retourneert de grotere van de twee, waarbij het bestelcriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

left
De eerste van de twee objecten die worden vergeleken.

right
De tweede van de twee objecten die worden vergeleken.

pred
Een binair predicaat dat wordt gebruikt om de twee objecten te vergelijken.

inlist
De initialisatielijst die de objecten bevat die moeten worden vergeleken.

Retourwaarde

Hoe groter de twee objecten, tenzij geen van beide groter is; in dat geval wordt de eerste van de twee objecten geretourneerd. Wanneer een initializer_list object is opgegeven, wordt het grootste van de objecten in de lijst geretourneerd.

Opmerkingen

Het max algoritme is ongebruikelijk bij het doorgeven van objecten als parameters. De meeste C++ Standaardbibliotheekalgoritmen werken op een reeks elementen waarvan de positie wordt opgegeven door iterators die als parameters worden doorgegeven. Als u een functie nodig hebt die werkt op een reeks elementen, gebruikt max_element u in plaats daarvan. Visual Studio 2017 maakt overbelastingen mogelijk constexpr die een initializer_list.

Voorbeeld

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

Hiermee vindt u het eerste exemplaar van het grootste element in een opgegeven bereik waarin het bestelcriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die de positie van het eerste element in het bereik aanpakt om naar het grootste element te zoeken.

last
Een doorstuur-iterator die de positie voorbij het laatste element in het bereik heeft om naar het grootste element te zoeken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het vergelijkingspredicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een doorstuurserver die de positie van het eerste exemplaar van het grootste element in het doorzochte bereik aanpakt.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De complexiteit is lineair: (last - first) - 1 vergelijkingen zijn vereist voor een niet-mptig bereik.

Voorbeeld

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

Combineert alle elementen van twee gesorteerde bronbereiken in één gesorteerd doelbereik, waarbij het bestelcriterium kan worden opgegeven met een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in de eerste van twee gesorteerde bronbereiken aanpakt die in één bereik moet worden gecombineerd en gesorteerd.

last1
Een invoer-iterator die de positie verhoudt tot het laatste element in de eerste van twee gesorteerde bronbereiken die moeten worden gecombineerd en gesorteerd in één bereik.

first2
Een invoer-iterator die de positie van het eerste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt die in één bereik moeten worden gecombineerd en gesorteerd.

last2
Een invoer-iterator die de positie één voorbij het laatste element in de tweede van twee opeenvolgende gesorteerde bronbereiken heeft om te worden gecombineerd en gesorteerd in één bereik.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aanpakt, waarbij de twee bronbereiken moeten worden gecombineerd tot één gesorteerd bereik.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het vergelijkingspredicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een uitvoer-iterator die de positie één voorbij het laatste element in het gesorteerde doelbereik aanpakt.

Opmerkingen

De gesorteerde bronbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Het doelbereik mag geen van de bronbereiken overlappen en moet groot genoeg zijn om het doelbereik te bevatten.

De gesorteerde bronbereiken moeten elk worden gerangschikt als voorwaarde voor de toepassing van het merge algoritme in overeenstemming met dezelfde volgorde als het algoritme dat door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren.

De bewerking is stabiel omdat de relatieve volgorde van elementen binnen elk bereik behouden blijft in het doelbereik. De bronbereiken worden niet gewijzigd door het algoritme merge.

De waardetypen van de invoer-iterators moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen. Wanneer er equivalente elementen in beide bronbereiken zijn, gaan de elementen in het eerste bereik vooraf aan de elementen uit het tweede bronbereik in het doelbereik.

De complexiteit van het algoritme is lineair met maximaal (last1 - first1) - (last2 - first2) - 1 vergelijkingen.

De list klasse biedt een lidfunctie merge om de elementen van twee lijsten samen te voegen.

Voorbeeld

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

Vergelijkt twee objecten en retourneert de mindere van de twee, waarbij het rangordecriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

left
De eerste van de twee objecten die worden vergeleken.

right
De tweede van de twee objecten die worden vergeleken.

pred
Een binair predicaat dat wordt gebruikt om de twee objecten te vergelijken.

inlist
De initializer_list leden die moeten worden vergeleken.

Retourwaarde

De mindere van de twee voorwerpen, tenzij geen van beide minder is; in dat geval wordt de eerste van de twee objecten geretourneerd. Wanneer een initializer_list object is opgegeven, wordt het minste van de objecten in de lijst geretourneerd.

Opmerkingen

Het min algoritme is ongebruikelijk bij het doorgeven van objecten als parameters. De meeste C++ Standaardbibliotheekalgoritmen werken op een reeks elementen waarvan de positie wordt opgegeven door iterators die als parameters worden doorgegeven. Als u een functie nodig hebt die gebruikmaakt van een reeks elementen, gebruikt u min_element. constexpr is ingeschakeld voor de initializer_list overbelasting in Visual Studio 2017.

Voorbeeld

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

Hiermee wordt gezocht naar het eerste exemplaar van het kleinste element in een opgegeven bereik, waarbij het bestelcriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die de positie van het eerste element in het bereik aanpakt om naar het kleinste element te zoeken.

last
Een doorstuur-iterator die de positie één voorbij het laatste element in het bereik heeft om naar het kleinste element te zoeken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het vergelijkingspredicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een doorstuur iterator die de positie van het eerste exemplaar van het kleinste element in het doorzochte bereik aanpakt.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De complexiteit is lineair: (last - first) - 1 vergelijkingen zijn vereist voor een niet-mptig bereik.

Voorbeeld

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

Voert het werk uit dat wordt uitgevoerd door min_element en max_element in één aanroep.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die het begin van een bereik aangeeft.

last
Een doorstuur iterator die het einde van een bereik aangeeft.

pred
Een door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Het vergelijkingspredicaat heeft twee argumenten en moet worden geretourneerd true wanneer de eerste kleiner is dan de tweede en false anders.

Retourwaarde

Retouren

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

Opmerkingen

De eerste sjabloonfunctie retourneert

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

De tweede sjabloonfunctie gedraagt zich hetzelfde, behalve dat deze wordt vervangen door operator<(X, Y)pred(X, Y).

Als de reeks niet leeg is, wordt de functie op de meeste 3 * (last - first - 1) / 2 vergelijkingen uitgevoerd.

minmax

Vergelijkt twee invoerparameters en retourneert deze als een paar, in volgorde van kleiner naar groter.

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

Parameterwaarden

left
De eerste van de twee objecten die worden vergeleken.

right
De tweede van de twee objecten die worden vergeleken.

pred
Een binair predicaat dat wordt gebruikt om de twee objecten te vergelijken.

inlist
De initializer_list leden die moeten worden vergeleken.

Opmerkingen

De eerste sjabloonfunctie retourneert pair<const Type&, const Type&>( right, left ) als right deze kleiner is dan left. Anders retourneert het pair<const Type&, const Type&>( left, right ).

De functie tweede lid retourneert een paar waarbij het eerste element het kleiner is en de tweede de groter is in vergelijking met het predicaat pred.

De resterende sjabloonfuncties gedragen zich hetzelfde, behalve dat ze de left en right parameters vervangen door inlist.

De functie voert precies één vergelijking uit.

mismatch

Vergelijkt twee bereiken-element per element en zoekt de eerste positie waar een verschil optreedt.

Gebruik de overbelastingen met twee bereiken in C++14-code omdat de overbelastingen die slechts één iterator voor het tweede bereik nemen, geen verschillen detecteren als het tweede bereik langer is dan het eerste bereik. Deze overbelastingen leiden tot niet-gedefinieerd gedrag als het tweede bereik korter is dan het eerste bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in het eerste bereik aanpakt dat moet worden getest.

last1
Een invoer-iterator die de positie na het laatste element in het eerste bereik aangeeft dat moet worden getest.

first2
Een invoer-iterator die de positie van het eerste element in het tweede bereik aanpakt dat moet worden getest.

last2
Een invoer-iterator die de positie van één voorbij het laatste element in het tweede bereik aangeeft dat moet worden getest.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject waarmee de huidige elementen in elk bereik worden vergeleken en wordt bepaald of ze gelijkwaardig zijn. Het retourneert true wanneer tevreden en false wanneer niet tevreden.

Retourwaarde

Retourneert een paar iterators die de posities van de verschillen in de twee bereiken aanpakken. De eerste component-iterator verwijst naar de positie in het eerste bereik. De iterator van het tweede onderdeel verwijst naar de positie in het tweede bereik. Als er geen verschil is tussen de elementen in de bereiken vergeleken of als aan het binaire predicaat in de tweede versie wordt voldaan door alle elementparen van de twee bereiken, wijst de eerste component-iterator naar de positie één voorbij het laatste element in het eerste bereik en verwijst de tweede component-iterator naar een positie die voorbij het laatste element in het tweede bereik is getest.

Opmerkingen

Bij de eerste sjabloonfunctie wordt ervan uitgegaan dat er net zoveel elementen in het bereik staan dat begint bij eerste2 als in het bereik dat is aangewezen door [eerste1, laatste1). Als er meer in het tweede bereik zijn, worden ze genegeerd; als er minder zijn, resulteert niet-gedefinieerd gedrag.

Het bereik dat moet worden doorzocht, moet geldig zijn; alle iterators moeten deductiebaar zijn en de laatste positie is bereikbaar vanaf de eerste door incrementatie.

De tijdcomplexiteit van het algoritme is lineair in het aantal elementen in het kortere bereik.

Het door de gebruiker gedefinieerde predicaat hoeft geen gelijkwaardigheidsrelatie op te leggen die symmetrisch, reflexief en transitief is tussen de operanden.

Voorbeeld

In het volgende voorbeeld ziet u hoe u niet-overeenkomend gebruikt. De C++03-overbelasting wordt alleen weergegeven om te laten zien hoe het een onverwacht resultaat kan opleveren.

#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

Elementen verplaatsen die zijn gekoppeld aan een opgegeven bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die aangeeft waar het bereik van elementen moet worden gestart dat moet worden verplaatst.

last
Een invoer-iterator die het einde van een bereik met elementen aangeeft dat moet worden verplaatst.

dest
De uitvoer-iterator die de verplaatste elementen bevat.

Opmerkingen

De sjabloonfunctie evalueert *(dest + N) = move(*(first + N)) één keer voor elk N in het bereik [0, last - first), om strikt toenemende waarden te N beginnen met de laagste waarde. Vervolgens wordt het geretourneerd dest + N. Als dest en first regio's van opslag aanwijzen, dest mag deze zich niet in het bereik bevinden [first, last).

move_backward

Hiermee verplaatst u de elementen van de ene iterator naar de andere. De verplaatsing begint met het laatste element in een opgegeven bereik en eindigt met het eerste element in dat bereik.

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

Parameterwaarden

first
Een iterator die het begin van een bereik aangeeft waaruit elementen moeten worden verplaatst.

last
Een iterator die het einde van een bereik aangeeft waaruit elementen moeten worden verplaatst. Dit element wordt niet verplaatst.

destEnd
Een bidirectionele iterator die de positie van één voorbij het laatste element in het doelbereik aanpakt.

Opmerkingen

De sjabloonfunctie evalueert *(destEnd - N - 1) = move(*(last - N - 1)) één keer voor elk N in het bereik [0, last - first), om strikt toenemende waarden te N beginnen met de laagste waarde. Vervolgens wordt het geretourneerd destEnd - (last - first). Als destEnd en first regio's van opslag aanwijzen, destEnd mag deze zich niet in het bereik bevinden [first, last).

move en move_backward zijn functioneel gelijk aan het gebruik copy en copy_backward met een verplaatsings-iterator.

next_permutation

Hiermee rangschikt u de elementen in een bereik zodat de oorspronkelijke volgorde wordt vervangen door de lexicografische volgende grotere permutatie als deze bestaat. De zin van lexicografisch volgende kan worden opgegeven met een binair predicaat.

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

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

Parameterwaarden

first
Een bidirectionele iterator die verwijst naar de positie van het eerste element in het bereik dat moet worden permuteerd.

last
Een bidirectionele iterator die verwijst naar de positie één voorbij het laatste element in het bereik dat moet worden permuteerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

true indien de lexicografische volgende permutatie bestaat en de oorspronkelijke volgorde van het bereik heeft vervangen; in falsedat geval wordt de volgorde omgezet in de lexicografische kleinste permutatie.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Het standaard binaire predicaat is kleiner dan en de elementen in het bereik moeten kleiner zijn dan vergelijkbaar om ervoor te zorgen dat de volgende permutatie goed is gedefinieerd.

De complexiteit is lineair met maximaal (last - first) / 2 wisselingen.

Voorbeeld

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

Partitioneert een reeks elementen, waarbij het ndeelement van de reeks correct wordt gezocht in het bereik dat aan deze criteria voldoet: Alle elementen voor deze elementen zijn kleiner dan of gelijk aan het element en alle elementen die erop volgen, zijn groter dan of gelijk aan het.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een iterator voor willekeurige toegang die de positie van het eerste element in het bereik aangeeft dat moet worden gepartitioneerd.

nth
Een iterator voor willekeurige toegang die de positie van het element op de juiste volgorde plaatst op de grens van de partitie.

last
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in het bereik heeft om te worden gepartitioneerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een vergelijkingspredicaat heeft twee argumenten en retourneert true wanneer er wordt voldaan en false wanneer niet is voldaan.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Het nth_element algoritme garandeert niet dat elementen in de subbereiken beide zijden van het ndeelement worden gesorteerd. Het maakt dus minder garanties dan partial_sort, waardoor de elementen in het bereik onder een bepaald element worden besteld en kunnen worden gebruikt als een sneller alternatief partial_sort voor wanneer de volgorde van het lagere bereik niet vereist is.

Elementen zijn gelijkwaardig, maar niet noodzakelijkerwijs gelijk, als geen van beide minder is dan de andere.

Het gemiddelde van een sorteercomplexiteit is lineair met betrekking tot last - first.

Voorbeeld

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

Retourneert true wanneer een voorwaarde nooit aanwezig is tussen elementen in het opgegeven bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die aangeeft waar een bereik van elementen voor een voorwaarde moet worden gecontroleerd.

last
Een invoer-iterator die het einde van een bereik van elementen aangeeft.

pred
De voorwaarde om op te testen. Deze test wordt geleverd door een door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Retourneert true als de voorwaarde niet ten minste één keer in het aangegeven bereik wordt gedetecteerd en false als de voorwaarde wordt gedetecteerd.

Opmerkingen

De sjabloonfunctie retourneert true alleen als, voor sommige N in het bereik [0, last - first), het predicaat pred(*(first + N)) altijd falseis.

partial_sort

Rangschikt een opgegeven aantal van de kleinere elementen in een bereik in een niet-oplopende volgorde. Een binair predicaat kan een bestelcriterium leveren.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een iterator voor willekeurige toegang heeft betrekking op de positie van het eerste element in het bereik dat moet worden gesorteerd.

sortEnd
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in de subbereik heeft om te worden gesorteerd.

last
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in het bereik heeft om gedeeltelijk te worden gesorteerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Elementen zijn gelijkwaardig, maar niet noodzakelijkerwijs gelijk, als geen van beide minder is dan de andere. Het sort algoritme is niet stabiel en garandeert niet dat de relatieve volgorde van equivalente elementen behouden blijft. Het algoritme stable_sort behoudt deze oorspronkelijke volgorde.

De gemiddelde complexiteit van gedeeltelijke sortering is O((last- first) log (sortEnd- first)).

Voorbeeld

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

Kopieert elementen uit een bronbereik naar een doelbereik waarin de bronelementen worden gerangschikt op minder dan of een ander opgegeven binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in het bronbereik aanpakt.

last1
Een invoer-iterator die de positie één voorbij het laatste element in het bronbereik aanpakt.

first2
Een iterator voor willekeurige toegang die de positie van het eerste element in het gesorteerde doelbereik aanpakt.

last2
Een iterator voor willekeurige toegang die de positie na het laatste element in het gesorteerde doelbereik aangeeft.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een iterator voor willekeurige toegang die het element in het doelbereik één positie heeft boven het laatste element dat is ingevoegd vanuit het bronbereik.

Opmerkingen

De bron- en doelbereiken mogen niet overlappen en moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Het binaire predicaat moet een strikte zwakke volgorde bieden, zodat elementen die niet gelijkwaardig zijn, geordend zijn, maar elementen die gelijkwaardig zijn niet. Twee elementen zijn gelijk onder minder dan, maar niet noodzakelijkerwijs gelijk, als geen van beide minder is dan de andere.

Voorbeeld

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

Classificeert elementen in een bereik in twee niet-aaneengesloten sets, waarbij deze elementen voldoen aan een unary predicaat voorafgaand aan de elementen die niet aan deze elementen voldoen.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een bidirectionele iterator die de positie van het eerste element in het bereik aanpakt dat moet worden gepartitioneerd.

last
Een bidirectionele iterator die de positie één voorbij het laatste element in het bereik richt dat moet worden gepartitioneerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als een element moet worden geclassificeerd. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Een bidirectionele iterator die de positie van het eerste element in het bereik aanpakt om niet te voldoen aan de predicaatvoorwaarde.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Elementen a en b zijn gelijkwaardig, maar niet noodzakelijkerwijs gelijk, als beide pred( a, b ) onwaar en pred( b, a ) onwaar zijn, waar pred is het predicaat dat door de parameter is opgegeven. Het partition algoritme is niet stabiel en garandeert niet dat de relatieve volgorde van equivalente elementen behouden blijft. Het algoritme stable_partition behoudt deze oorspronkelijke volgorde.

De complexiteit is lineair: er zijn (last - first) toepassingen van pred en maximaal (last - first)/2 wisselingen.

Voorbeeld

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

Hiermee kopieert u elementen waarvan een voorwaarde naar de ene bestemming is true en waarvan de voorwaarde naar een andere is false . De elementen moeten afkomstig zijn van een opgegeven bereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die het begin van een bereik aangeeft om te controleren op een voorwaarde.

last
Een invoer-iterator die het einde van een bereik aangeeft.

dest1
Een uitvoer-iterator die wordt gebruikt om elementen te kopiëren die waar retourneren voor een voorwaarde die is getest met behulp van pred.

dest2
Een uitvoer-iterator die wordt gebruikt om elementen te kopiëren die onwaar retourneren voor een voorwaarde die is getest met behulp van pred.

pred
De voorwaarde om op te testen. De test wordt geleverd door een door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert die moet worden getest. Een unaire predicaat heeft één argument en retourneert true of false.

Opmerkingen

Met de sjabloonfunctie wordt elk element X gekopieerd naar [first,last)*dest1++ indien pred(X) waar of *dest2++ niet. Het geeft pair<OutputIterator1, OutputIterator2>(dest1, dest2) terug.

partition_point

Retourneert het eerste element in het opgegeven bereik dat niet voldoet aan de voorwaarde. De elementen worden zodanig gesorteerd dat de elementen die aan de voorwaarde voldoen, vóór de elementen komen die niet voldoen.

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

Parameterwaarden

first
Een ForwardIterator die het begin van een bereik aangeeft om te controleren op een voorwaarde.

last
Een ForwardIterator die het einde van een bereik aangeeft.

pred
De voorwaarde om op te testen. De test wordt geleverd door een door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan door het element waarnaar wordt gezocht. Een unaire predicaat heeft één argument en retourneert true of false.

Retourwaarde

Retourneert een ForwardIterator element dat verwijst naar het eerste element dat niet voldoet aan de voorwaarde die is getest door pred, of retourneert last als een element niet wordt gevonden.

Opmerkingen

Met de sjabloonfunctie wordt de eerste iterator it gevonden [first, last) waarvoor pred(*it)false. De volgorde moet worden geordend op pred.

pop_heap

Hiermee verwijdert u het grootste element van de voorzijde van een heap naar de dichtstbijzijnde laatste positie in het bereik en vormt vervolgens een nieuwe heap van de resterende elementen.

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

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

Parameterwaarden

first
Een iterator voor willekeurige toegang die de positie van het eerste element in de heap aanpakt.

last
Een iterator voor willekeurige toegang adresseren de positie één voorbij het laatste element in de heap.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Opmerkingen

Het pop_heap algoritme is de inverse van de bewerking die wordt uitgevoerd door het push_heap-algoritme, waarin een element op de naast-laatste positie van een bereik wordt toegevoegd aan een heap die bestaat uit de vorige elementen in het bereik, in het geval dat het element wordt toegevoegd aan de heap groter is dan een van de elementen die al in de heap aanwezig zijn.

Heaps hebben twee eigenschappen:

• Het eerste element is altijd de grootste.

• Elementen kunnen in logaritmische tijd worden toegevoegd of verwijderd.

Heaps zijn een ideale manier om prioriteitswachtrijen te implementeren en ze worden gebruikt in de implementatie van de C++ Standard Library-containeradapter priority_queue Klasse.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Het bereik met uitzondering van het zojuist toegevoegde element aan het einde moet een heap zijn.

De complexiteit is logaritmisch en vereist maximaal log (last - first) vergelijkingen.

Voorbeeld

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

Hiermee rangschikt u de elementen in een bereik zodanig dat de oorspronkelijke volgorde wordt vervangen door de lexicografische eerdere grotere permutatie als deze bestaat. Een binair predicaat kan de betekenis van lexicografisch eerder aangeven.

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

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

Parameterwaarden

first
Een bidirectionele iterator die verwijst naar de positie van het eerste element in het bereik dat moet worden permuteerd.

last
Een bidirectionele iterator die verwijst naar de positie één voorbij het laatste element in het bereik dat moet worden permuteerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

true indien de lexicografische permutatie bestaat en de oorspronkelijke volgorde van het bereik heeft vervangen; in falsedat geval wordt de volgorde omgezet in de lexicografische grootste permutatie.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Het standaard binaire predicaat is kleiner dan en de elementen in het bereik moeten kleiner zijn dan vergelijkbaar om ervoor te zorgen dat de vorige permutatie goed is gedefinieerd.

De complexiteit is lineair, met maximaal (last - first)/2 wissels.

Voorbeeld

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

Hiermee voegt u een element toe dat zich aan het einde van een bereik bevindt aan een bestaande heap die bestaat uit de voorgaande elementen in het bereik.

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

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

Parameterwaarden

first
Een iterator voor willekeurige toegang die de positie van het eerste element in de heap aanpakt.

last
Een iterator voor willekeurige toegang die de positie voorbij het laatste element in het bereik heeft om te worden omgezet in een heap.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Opmerkingen

Het element moet eerst naar het einde van een bestaande heap worden gepusht en vervolgens wordt het algoritme gebruikt om dit element toe te voegen aan de bestaande heap.

Heaps hebben twee eigenschappen:

• Het eerste element is altijd de grootste.

• Elementen kunnen in logaritmische tijd worden toegevoegd of verwijderd.

Heaps zijn een ideale manier om prioriteitswachtrijen te implementeren en ze worden gebruikt in de implementatie van de C++ Standard Library-containeradapter priority_queue Klasse.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Het bereik met uitzondering van het zojuist toegevoegde element aan het einde moet een heap zijn.

De complexiteit is logaritmisch en vereist maximaal log(last - first) vergelijkingen.

Voorbeeld

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

De std::random_shuffle() functie is afgeschaft, vervangen door std::shuffle. Zie en de Stack Overflow-post Waarom worden std::random_shuffle methoden afgeschaft in C++14 voor een codevoorbeeld en meer informatie<random>.

remove

Elimineert een opgegeven waarde uit een bepaald bereik zonder de volgorde van de resterende elementen te storen. Retourneert het einde van een nieuw bereik vrij van de opgegeven waarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die de positie van het eerste element in het bereik aangeeft waaruit elementen worden verwijderd.

last
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik krijgt van waaruit elementen worden verwijderd.

value
De waarde die uit het bereik moet worden verwijderd.

Retourwaarde

Een doorstuur iterator die de nieuwe eindpositie van het gewijzigde bereik aanpakt, één voorbij het laatste element van de restantenreeks vrij van de opgegeven waarde.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De volgorde van de elementen die niet zijn verwijderd, blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid.

De list klasse heeft een efficiëntere lidfunctieversie van remove, waarmee ook aanwijzers opnieuw worden gekoppeld.

Voorbeeld

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

Kopieert elementen van een bronbereik naar een doelbereik, behalve dat elementen van een opgegeven waarde niet worden gekopieerd, zonder de volgorde van de resterende elementen te storen. Retourneert het einde van een nieuw doelbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die de positie van het eerste element in het bereik aangeeft van waaruit elementen worden verwijderd.

last
Een invoer-iterator die de positie na het laatste element in het bereik afspreekt van waaruit elementen worden verwijderd.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aangeeft waarop elementen worden verwijderd.

value
De waarde die uit het bereik moet worden verwijderd.

Retourwaarde

Een doorstuur iterator die de nieuwe eindpositie van het doelbereik aanpakt, één voorbij het laatste element van de kopie van de restantenreeks vrij van de opgegeven waarde.

Opmerkingen

De bron- en doelbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Er moet voldoende ruimte in het doelbereik zijn om de restantenelementen te bevatten die worden gekopieerd nadat elementen van de opgegeven waarde zijn verwijderd.

De volgorde van de elementen die niet zijn verwijderd, blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid en maximaal (last - first) toewijzingen.

Voorbeeld

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

Kopieert elementen van een bronbereik naar een doelbereik, met uitzondering van elementen die voldoen aan een predicaat. Elementen worden gekopieerd zonder de volgorde van de resterende elementen te storen. Retourneert het einde van een nieuw doelbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die de positie van het eerste element in het bereik aangeeft van waaruit elementen worden verwijderd.

last
Een invoer-iterator die de positie na het laatste element in het bereik afspreekt van waaruit elementen worden verwijderd.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aangeeft waarop elementen worden verwijderd.

pred
Het unaire predicaat waaraan moet worden voldaan, is de waarde van een element dat moet worden vervangen.

Retourwaarde

Een doorstuur iterator die de nieuwe eindpositie van het doelbereik aanpakt, één voorbij het laatste element van de overblijfselenreeks vrij van de elementen die aan het predicaat voldoen.

Opmerkingen

Het bronbereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Er moet voldoende ruimte in het doelbereik zijn om de restantenelementen te bevatten die worden gekopieerd nadat elementen van de opgegeven waarde zijn verwijderd.

De volgorde van de elementen die niet zijn verwijderd, blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid en maximaal (last - first) toewijzingen.

Zie Controle-iterators voor informatie over hoe deze functies zich gedragen.

Voorbeeld

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

Elimineert elementen die voldoen aan een predicaat uit een bepaald bereik zonder de volgorde van de resterende elementen te storen. Retourneert het einde van een nieuw bereik vrij van de opgegeven waarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die verwijst naar de positie van het eerste element in het bereik van waaruit elementen worden verwijderd.

last
Een doorstuur iterator die verwijst naar de positie één voorbij het laatste element in het bereik van waaruit elementen worden verwijderd.

pred
Het unaire predicaat waaraan moet worden voldaan, is de waarde van een element dat moet worden vervangen.

Retourwaarde

Een doorstuur iterator die de nieuwe eindpositie van het gewijzigde bereik aanpakt, één voorbij het laatste element van de restantenreeks vrij van de opgegeven waarde.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De volgorde van de elementen die niet zijn verwijderd, blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid.

Lijst heeft een efficiëntere versie van de lidfunctie van verwijderen waarmee aanwijzers opnieuw worden gekoppeld.

Voorbeeld

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

Onderzoekt elk element in een bereik en vervangt dit als het overeenkomt met een opgegeven waarde.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuurserver die verwijst naar de positie van het eerste element in het bereik waaruit elementen worden vervangen.

last
Een doorstuurserver die verwijst naar de positie één voorbij het laatste element in het bereik van waaruit elementen worden vervangen.

oldVal
De oude waarde van de elementen die worden vervangen.

newVal
De nieuwe waarde die wordt toegewezen aan de elementen met de oude waarde.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De volgorde van de niet vervangen elementen blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid en maximaal (last - first) toewijzingen van nieuwe waarden.

Voorbeeld

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

Onderzoekt elk element in een bronbereik en vervangt dit als het overeenkomt met een opgegeven waarde tijdens het kopiëren van het resultaat naar een nieuw doelbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die verwijst naar de positie van het eerste element in het bereik van waaruit elementen worden vervangen.

last
Een invoer-iterator die verwijst naar de positie één voorbij het laatste element in het bereik van waaruit elementen worden vervangen.

result
Een uitvoer-iterator die verwijst naar het eerste element in het doelbereik waar de gewijzigde reeks elementen wordt gekopieerd.

oldVal
De oude waarde van de elementen die worden vervangen.

newVal
De nieuwe waarde die wordt toegewezen aan de elementen met de oude waarde.

Retourwaarde

Een uitvoer-iterator die verwijst naar de positie die één voorbij het laatste element in het doelbereik wijst, wordt de gewijzigde reeks elementen gekopieerd naar.

Opmerkingen

De bron- en doelbereiken waarnaar wordt verwezen, mogen niet overlappen en moeten beide geldig zijn: alle aanwijzers moeten deducteerbaar zijn en binnen de reeksen is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De volgorde van de niet vervangen elementen blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid en maximaal (last - first) toewijzingen van nieuwe waarden.

Voorbeeld

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

Vanwege de random_shuffle() aanroep in de voorgaande code kan de uitvoer afwijken.

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

Onderzoekt elk element in een bronbereik en vervangt dit als het voldoet aan een opgegeven predicaat tijdens het kopiëren van het resultaat naar een nieuw doelbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een invoer-iterator die verwijst naar de positie van het eerste element in het bereik van waaruit elementen worden vervangen.

last
Een invoer-iterator die verwijst naar de positie één voorbij het laatste element in het bereik van waaruit elementen worden vervangen.

result
Een uitvoer-iterator die verwijst naar de positie van het eerste element in het doelbereik waarnaar elementen worden gekopieerd.

pred
Het unaire predicaat waaraan moet worden voldaan, is de waarde van een element dat moet worden vervangen.

value
De nieuwe waarde die wordt toegewezen aan de elementen waarvan de oude waarde voldoet aan het predicaat.

Retourwaarde

Een uitvoer-iterator die verwijst naar de positie die één voorbij het laatste element in het doelbereik wijst, wordt de gewijzigde reeks elementen gekopieerd naar.

Opmerkingen

De bron- en doelbereiken waarnaar wordt verwezen, mogen niet overlappen en moeten beide geldig zijn: alle aanwijzers moeten deducteerbaar zijn en binnen de reeksen is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De volgorde van de niet vervangen elementen blijft stabiel.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid en maximaal (last - first) toewijzingen van nieuwe waarden.

Voorbeeld

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

Onderzoekt elk element in een bereik en vervangt het als het voldoet aan een opgegeven predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuurserver die verwijst naar de positie van het eerste element in het bereik waaruit elementen worden vervangen.

last
Een iterator die verwijst naar de positie één voorbij het laatste element in het bereik van waaruit elementen worden vervangen.

pred
Het unaire predicaat waaraan moet worden voldaan, is de waarde van een element dat moet worden vervangen.

value
De nieuwe waarde die wordt toegewezen aan de elementen waarvan de oude waarde voldoet aan het predicaat.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De volgorde van de niet vervangen elementen blijft stabiel.

Het algoritme replace_if is een generalisatie van het algoritme replace, waardoor elk predicaat kan worden opgegeven, in plaats van gelijkheid met een opgegeven constante waarde.

De operator== gebruikte methode om de gelijkheid tussen elementen vast te stellen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De complexiteit is lineair. Het maakt (last - first) vergelijkingen voor gelijkheid en maximaal (last - first) toewijzingen van nieuwe waarden.

Voorbeeld

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

Hiermee wordt de volgorde van de elementen binnen een bereik omgekeerd.

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

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een bidirectionele iterator die verwijst naar de positie van het eerste element in het bereik waarin de elementen worden permuteerd.

last
Een bidirectionele iterator die verwijst naar de positie één voorbij het laatste element in het bereik waarin de elementen worden permuteerd.

Opmerkingen

Het bronbereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Voorbeeld

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

Hiermee wordt de volgorde van de elementen binnen een bronbereik omgekeerd tijdens het kopiëren naar een doelbereik

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een bidirectionele iterator die verwijst naar de positie van het eerste element in het bronbereik waarin de elementen worden permuteerd.

last
Een bidirectionele iterator die verwijst naar de positie één voorbij het laatste element in het bronbereik waarin de elementen worden permuteerd.

result
Een uitvoer-iterator die verwijst naar de positie van het eerste element in het doelbereik waarnaar elementen worden gekopieerd.

Retourwaarde

Een uitvoer-iterator die verwijst naar de positie die één voorbij het laatste element in het doelbereik wijst, wordt de gewijzigde reeks elementen gekopieerd naar.

Opmerkingen

De bron- en doelbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Voorbeeld

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

Wisselt de elementen in twee aangrenzende bereiken uit.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die de positie van het eerste element in het bereik aangeeft dat moet worden gedraaid.

middle
Een doorstuurserver die de grens binnen het bereik definieert die de positie van het eerste element in het tweede deel van het bereik aangeeft waarvan de elementen moeten worden uitgewisseld met de elementen in het eerste deel van het bereik.

last
Een doorstuur iterator die de positie na het laatste element in het bereik aangeeft dat moet worden gedraaid.

Opmerkingen

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De complexiteit is lineair. Het maakt maximaal (last - first) wissels.

Voorbeeld

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

Wisselt de elementen uit in twee aangrenzende bereiken binnen een bronbereik en kopieert het resultaat naar een doelbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die de positie van het eerste element in het bereik aangeeft dat moet worden gedraaid.

middle
Een doorstuurserver die de grens binnen het bereik definieert die de positie van het eerste element in het tweede deel van het bereik aangeeft waarvan de elementen moeten worden uitgewisseld met de elementen in het eerste deel van het bereik.

last
Een doorstuur iterator die de positie na het laatste element in het bereik aangeeft dat moet worden gedraaid.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aanpakt.

Retourwaarde

Een uitvoer-iterator die de positie één voorbij het laatste element in het doelbereik aanpakt.

Opmerkingen

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De complexiteit is lineair. Het maakt maximaal (last - first) wissels.

Voorbeeld

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

Hiermee wordt gezocht naar het eerste exemplaar van een reeks binnen een doelbereik waarvan de elementen gelijk zijn aan de elementen in een bepaalde reeks elementen of waarvan de elementen gelijkwaardig zijn in een zin die is opgegeven door een binair predicaat voor de elementen in de opgegeven reeks.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last1
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

first2
Een doorstuur iterator die de positie van het eerste element in het bereik aanspreekt dat moet worden vergeleken.

last2
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te worden vergeleken.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

searcher
De zoekfunctie die het patroon inkapselt om te zoeken naar en het zoekalgoritmen dat moet worden gebruikt. Zie klasse, boyer_moore_horspool_searcher klasse en boyer_moore_searcher klasse voor meer informatie over zoekfunctiesdefault_searcher.

Retourwaarde

Een doorstuur iterator die de positie van het eerste element van de eerste subsequence aanpakt die overeenkomt met de opgegeven reeks of die gelijkwaardig is in een zin die is opgegeven door een binair predicaat.

Opmerkingen

De operator== gebruikt om de overeenkomst tussen een element en de opgegeven waarde te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De gemiddelde complexiteit is lineair met betrekking tot de grootte van het gezochte bereik. De complexiteit van het slechtste geval is ook lineair met betrekking tot de grootte van de reeks die wordt gezocht.

Voorbeeld

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

Zoekt naar de eerste subsquence in een bereik dat van een opgegeven aantal elementen met een bepaalde waarde of een relatie met die waarde, zoals opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren dat moet worden doorzocht.

last1
Een doorstuur iterator die de positie één voorbij het laatste element in het bereik heeft om te doorzoeken.

count
De grootte van de subsequence die wordt gezocht.

value
De waarde van de elementen in de volgorde die wordt gezocht.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een doorstuur iterator die de positie van het eerste element van de eerste subsequence aanpakt die overeenkomt met de opgegeven reeks of die gelijkwaardig is in een zin die is opgegeven door een binair predicaat.

Opmerkingen

De operator== gebruikt om de overeenkomst tussen een element en de opgegeven waarde te bepalen, moet een gelijkwaardigheidsrelatie tussen de operanden opleggen.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Complexiteit is lineair met betrekking tot de grootte van de gezochte.

Voorbeeld

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

Combineert alle elementen die deel uitmaken van één gesorteerd bronbereik, maar niet tot een tweede gesorteerd bronbereik, in één gesorteerd doelbereik. Een binair predicaat kan het bestelcriterium opgeven.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in de eerste van twee gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat het verschil van de twee bronbereiken aangeeft.

last1
Een invoer-iterator die de positie na het laatste element in de eerste van twee gesorteerde bronbereiken heeft om te worden samengevoegd en gesorteerd in één bereik dat het verschil van de twee bronbereiken aangeeft.

first2
Een invoer-iterator die de positie van het eerste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt die moeten worden samengevoegd en gesorteerd in één bereik dat het verschil van de twee bronbereiken vertegenwoordigt.

last2
Een invoer-iterator die de positie één voorbij het laatste element in de tweede van twee opeenvolgende gesorteerde bronbereiken heeft om te worden samengevoegd en gesorteerd in één bereik dat het verschil van de twee bronbereiken vertegenwoordigt.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aangeeft, waarbij de twee bronbereiken moeten worden samengevoegd tot één gesorteerd bereik dat het verschil van de twee bronbereiken vertegenwoordigt.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het binaire predicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een uitvoer-iterator die de positie na het laatste element in het gesorteerde doelbereik aangeeft dat het verschil van de twee bronbereiken aangeeft.

Opmerkingen

De gesorteerde bronbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Het doelbereik mag geen van de bronbereiken overlappen en moet groot genoeg zijn om het eerste bronbereik te bevatten.

De gesorteerde bronbereiken moeten elk worden gerangschikt als voorwaarde voor de toepassing van het set_difference algoritme in overeenstemming met dezelfde volgorde als het algoritme dat door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren.

De bewerking is stabiel omdat de relatieve volgorde van elementen binnen elk bereik behouden blijft in het doelbereik. De bronbereiken worden niet gewijzigd door de algoritmesamenvoeging.

De waardetypen van de invoer-iterators moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen. Wanneer er equivalente elementen in beide bronbereiken zijn, gaan de elementen in het eerste bereik vooraf aan de elementen uit het tweede bronbereik in het doelbereik. Als de bronbereiken duplicaten van een element bevatten, zodat het eerste bronbereik groter is dan in het tweede bronbereik, bevat het doelbereik het getal waarmee de exemplaren van die elementen in het eerste bronbereik de exemplaren van die elementen in het tweede bronbereik overschrijden.

De complexiteit van het algoritme is lineair met op de meeste 2 * ((last1 - first1) + (last2 - first2)) - 1 vergelijkingen voor lege bronbereiken.

Voorbeeld

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

Combineert alle elementen die deel uitmaken van beide gesorteerde bronbereiken in één gesorteerd doelbereik, waarbij het volgordecriterium kan worden opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in de eerste van twee gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat het snijpunt van de twee bronbereiken vertegenwoordigt.

last1
Een invoer-iterator die de positie na het laatste element in de eerste van twee gesorteerde bronbereiken heeft om te worden samengevoegd en gesorteerd in één bereik dat het snijpunt van de twee bronbereiken vertegenwoordigt.

first2
Een invoer-iterator die de positie van het eerste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt die moeten worden samengevoegd en gesorteerd in één bereik dat het snijpunt van de twee bronbereiken vertegenwoordigt.

last2
Een invoer-iterator die de positie één voorbij het laatste element in de tweede van twee opeenvolgende gesorteerde bronbereiken heeft om te worden samengevoegd en gesorteerd in één bereik dat het snijpunt van de twee bronbereiken vertegenwoordigt.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik adresseert, waarbij de twee bronbereiken moeten worden samengevoegd in één gesorteerd bereik dat het snijpunt van de twee bronbereiken vertegenwoordigt.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het binaire predicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een uitvoer-iterator die de positie na het laatste element in het gesorteerde doelbereik aangeeft dat het snijpunt van de twee bronbereiken vertegenwoordigt.

Opmerkingen

De gesorteerde bronbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Het doelbereik mag geen van de bronbereiken overlappen en moet groot genoeg zijn om het doelbereik te bevatten.

De gesorteerde bronbereiken moeten elk worden gerangschikt als een voorwaarde voor de toepassing van het samenvoegingsalgoritmen in overeenstemming met dezelfde volgorde als die door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren.

De bewerking is stabiel omdat de relatieve volgorde van elementen binnen elk bereik behouden blijft in het doelbereik. De bronbereiken worden niet gewijzigd door het algoritme.

De waardetypen van de invoer-iterators moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen. Wanneer er equivalente elementen in beide bronbereiken zijn, gaan de elementen in het eerste bereik vooraf aan de elementen uit het tweede bronbereik in het doelbereik. Als de bronbereiken duplicaten van een element bevatten, bevat het doelbereik het maximum aantal elementen dat in beide bronbereiken voorkomt.

De complexiteit van het algoritme is lineair met op de meeste 2 * ((last1 - first1) + (last2 - first2)) - 1 vergelijkingen voor lege bronbereiken.

Voorbeeld

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

Combineert alle elementen die tot één behoren, maar niet beide, van de gesorteerde bronbereiken in één gesorteerd doelbereik. Een binair predicaat kan het bestelcriterium opgeven.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in de eerste van twee gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat het symmetrische verschil van de twee bronbereiken vertegenwoordigt.

last1
Een invoer-iterator die de positie één voorbij het laatste element in de eerste van twee gesorteerde bronbereiken heeft om te worden samengevoegd en gesorteerd in één bereik dat het symmetrische verschil van de twee bronbereiken aangeeft.

first2
Een invoer-iterator die de positie van het eerste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat het symmetrische verschil van de twee bronbereiken aangeeft.

last2
Een invoer-iterator die de positie na het laatste element in de tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat het symmetrische verschil van de twee bronbereiken vertegenwoordigt.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aanspreekt, waarbij de twee bronbereiken moeten worden samengevoegd in één gesorteerd bereik dat het symmetrische verschil van de twee bronbereiken vertegenwoordigt.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het binaire predicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een uitvoer-iterator die de positie na het laatste element in het gesorteerde doelbereik aangeeft dat het symmetrische verschil van de twee bronbereiken aangeeft.

Opmerkingen

De gesorteerde bronbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Het doelbereik mag geen van de bronbereiken overlappen en moet groot genoeg zijn om het doelbereik te bevatten.

De gesorteerde bronbereiken moeten elk worden gerangschikt als voorwaarde voor de toepassing van het merge* algoritme in overeenstemming met dezelfde volgorde als het algoritme dat door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren.

De bewerking is stabiel omdat de relatieve volgorde van elementen binnen elk bereik behouden blijft in het doelbereik. De bronbereiken worden niet gewijzigd door de algoritmesamenvoeging.

De waardetypen van de invoer-iterators moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen. Wanneer er equivalente elementen in beide bronbereiken zijn, gaan de elementen in het eerste bereik vooraf aan de elementen uit het tweede bronbereik in het doelbereik. Als de bronbereiken duplicaten van een element bevatten, bevat het doelbereik de absolute waarde van het getal waarmee de exemplaren van deze elementen in een van de bronbereiken de exemplaren van die elementen in het tweede bronbereik overschrijden.

De complexiteit van het algoritme is lineair met op de meeste 2 * ((last1 - first1) + (last2 - first2)) - 1 vergelijkingen voor lege bronbereiken.

Voorbeeld

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

Combineert alle elementen die deel uitmaken van ten minste één van twee gesorteerde bronbereiken in één gesorteerd doelbereik. Een binair predicaat kan het bestelcriterium opgeven.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in de eerste van twee gesorteerde bronbereiken aanpakt die moeten worden samengevoegd en gesorteerd in één bereik dat de samenvoeging van de twee bronbereiken vertegenwoordigt.

last1
Een invoer-iterator die de positie na het laatste element in de eerste van twee gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat de samenvoeging van de twee bronbereiken vertegenwoordigt.

first2
Een invoer-iterator die de positie van het eerste element in het tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat de samenvoeging van de twee bronbereiken vertegenwoordigt.

last2
Een invoer-iterator die de positie na het laatste element in de tweede van twee opeenvolgende gesorteerde bronbereiken aanpakt om te worden samengevoegd en gesorteerd in één bereik dat de samenvoeging van de twee bronbereiken vertegenwoordigt.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik adresseert waarbij de twee bronbereiken moeten worden samengevoegd in één gesorteerd bereik dat de samenvoeging van de twee bronbereiken vertegenwoordigt.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Het binaire predicaat heeft twee argumenten en moet worden geretourneerd true wanneer het eerste element kleiner is dan het tweede element en false anders.

Retourwaarde

Een uitvoer-iterator die de positie na het laatste element in het gesorteerde doelbereik aangeeft dat de samenvoeging van de twee bronbereiken vertegenwoordigt.

Opmerkingen

De gesorteerde bronbereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Het doelbereik mag geen van de bronbereiken overlappen en moet groot genoeg zijn om het doelbereik te bevatten.

De gesorteerde bronbereiken moeten elk worden gerangschikt als voorwaarde voor de toepassing van het merge algoritme in overeenstemming met dezelfde volgorde als het algoritme dat door het algoritme moet worden gebruikt om de gecombineerde bereiken te sorteren.

De bewerking is stabiel omdat de relatieve volgorde van elementen binnen elk bereik behouden blijft in het doelbereik. De bronbereiken worden niet gewijzigd door het algoritme merge.

De waardetypen van de invoer-iterators moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen. Wanneer er equivalente elementen in beide bronbereiken zijn, gaan de elementen in het eerste bereik vooraf aan de elementen uit het tweede bronbereik in het doelbereik. Als de bronbereiken duplicaten van een element bevatten, bevat het doelbereik het maximum aantal elementen dat in beide bronbereiken voorkomt.

De complexiteit van het algoritme is lineair met maximaal 2 * ((last1 - first1) + (last2 - first2)) - 1 vergelijkingen.

Voorbeeld

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

Hiermee worden elementen voor een bepaald bereik herschikt (herschikken) met behulp van een generator voor willekeurige getallen.

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

Parameterwaarden

first
Een iterator voor het eerste element in het bereik dat in willekeurige volgorde moet worden gerangschikt. Moet voldoen aan de vereisten van RandomAccessIterator en ValueSwappable.

last
Een iterator tot het laatste element in het bereik dat moet worden in willekeurige volgorde geplaatst, exclusief. Moet voldoen aan de vereisten van RandomAccessIterator en ValueSwappable.

gen
De generator voor willekeurige getallen die door de shuffle() functie wordt gebruikt voor de bewerking. Moet voldoen aan de vereisten van een UniformRandomNumberGenerator.

Opmerkingen

Zie voor meer informatie en een codevoorbeeld dat gebruikmaakt shuffle()<random>van .

sort

Rangschikt de elementen in een opgegeven bereik in een niet-oplopende volgorde of volgens een volgordecriterium dat is opgegeven door een binair predicaat.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een iterator voor willekeurige toegang heeft betrekking op de positie van het eerste element in het bereik dat moet worden gesorteerd.

last
Een iterator voor willekeurige toegang die de positie één voorbij het laatste element in het bereik heeft om te worden gesorteerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Dit binaire predicaat heeft twee argumenten en retourneert true als de twee argumenten op volgorde staan en false anders. Deze comparatorfunctie moet een strikte zwakke volgorde opleggen aan paren elementen uit de reeks. Zie Algoritmen voor meer informatie.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Elementen zijn gelijkwaardig, maar niet noodzakelijkerwijs gelijk, als geen van beide minder is dan de andere. Het sort algoritme is niet stabiel en garandeert dus niet dat de relatieve volgorde van equivalente elementen behouden blijft. Het algoritme stable_sort behoudt deze oorspronkelijke volgorde.

Het gemiddelde van een sorteercomplexiteit is O( N log N ), waarbij N = last - first.

Voorbeeld

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

Converteert een heap naar een gesorteerd bereik.

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

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

Parameterwaarden

first
Een iterator voor willekeurige toegang die de positie van het eerste element in de doel-heap aanpakt.

last
Een iterator voor willekeurige toegang die de positie na het laatste element in de doel-heap aanpakt.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de betekenis definieert waarin het ene element kleiner is dan een ander element. Een vergelijkingspredicaat heeft twee argumenten en retourneert true wanneer er wordt voldaan en false wanneer niet is voldaan.

Opmerkingen

Heaps hebben twee eigenschappen:

• Het eerste element is altijd de grootste.

• Elementen kunnen in logaritmische tijd worden toegevoegd of verwijderd.

Na de toepassing als dit algoritme is toegepast, is het bereik waaraan het is toegepast, geen heap meer.

sort_heap is geen stabiele sortering omdat de relatieve volgorde van equivalente elementen niet noodzakelijkerwijs behouden blijft.

Heaps zijn een ideale manier om prioriteitswachtrijen te implementeren en ze worden gebruikt in de implementatie van de C++ Standard Library-containeradapterklassepriority_queue.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

De complexiteit is maximaal N log N, waarbij N = last - first.

Voorbeeld

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

Classificeert elementen in een bereik in twee niet-aaneengesloten sets, waarbij de elementen die voldoen aan een unary predicaat voorafgaand aan de elementen die niet aan het predicaat voldoen, de relatieve volgorde van equivalente elementen behouden.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een bidirectionele iterator die de positie van het eerste element in het bereik aanpakt dat moet worden gepartitioneerd.

last
Een bidirectionele iterator die de positie één voorbij het laatste element in het bereik richt dat moet worden gepartitioneerd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als een element moet worden geclassificeerd. Een unaire predicaat neemt één argument en retourneert true indien tevreden, of false niet tevreden.

Retourwaarde

Een bidirectionele iterator die de positie van het eerste element in het bereik aanpakt om niet te voldoen aan de predicaatvoorwaarde.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Elementen a en b zijn gelijkwaardig, maar niet noodzakelijkerwijs gelijk, als beide pred( a, b ) onwaar en pred( b, a ) onwaar zijn, waarbij pred het opgegeven predicaat van de parameter is. Het stable_partition algoritme is stabiel en garandeert dat de relatieve volgorde van equivalente elementen behouden blijft. Het algoritme partition behoudt deze oorspronkelijke volgorde niet noodzakelijkerwijs.

Voorbeeld

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

Rangschikt de elementen in een opgegeven bereik in een niet-oplopende volgorde of volgens een volgordecriterium dat is opgegeven door een binair predicaat. Het behoudt de relatieve volgorde van equivalente elementen.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een bidirectionele iterator die de positie van het eerste element in het bereik aanspreekt dat moet worden gesorteerd.

last
Een bidirectionele iterator die de positie één voorbij het laatste element in het bereik heeft om te sorteren.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat het vergelijkingscriterium definieert dat moet worden voldaan door opeenvolgende elementen in de volgorde. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Opmerkingen

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie.

Elementen zijn gelijkwaardig, maar niet noodzakelijkerwijs gelijk, als geen van beide minder is dan de andere. Het sort algoritme is stabiel en garandeert dat de relatieve volgorde van equivalente elementen behouden blijft.

De runtimecomplexiteit stable_sort is afhankelijk van de hoeveelheid geheugen die beschikbaar is, maar het beste geval (gegeven voldoende geheugen) is O(N log N) en het slechtste geval is O(N (log N)^2), waarbij N = last - first. Meestal is het sort algoritme sneller dan stable_sort.

Voorbeeld

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

Met de eerste onderdrukking worden de waarden van twee objecten uitgewisseld. Met de tweede onderdrukking worden de waarden tussen twee matrices van objecten uitgewisseld.

template<class Type>
void swap(
    Type& left,
    Type& right);
template<class Type, size_t N>
void swap(
    Type (& left)[N],
    Type (& right)[N]);

Parameterwaarden

left
Voor de eerste onderdrukking moet de inhoud van het eerste object worden uitgewisseld. Voor de tweede onderdrukking wordt de eerste matrix met objecten uitgewisseld.

right
Voor de eerste onderdrukking moet de inhoud van het tweede object worden uitgewisseld. Voor de tweede onderdrukking moet de tweede matrix met objecten de inhoud ervan laten uitwisselen.

Opmerkingen

De eerste overbelasting is ontworpen om op afzonderlijke objecten te werken. De tweede overbelasting wisselt de inhoud van objecten tussen twee matrices.

Voorbeeld

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

Wisselt de elementen van het ene bereik uit met de elementen van een ander, gelijk formaatbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een doorstuurserver die verwijst naar de eerste positie van het eerste bereik waarvan de elementen moeten worden uitgewisseld.

last1
Een doorstuur iterator die verwijst naar één na de laatste positie van het eerste bereik waarvan de elementen moeten worden uitgewisseld.

first2
Een doorstuurserver die verwijst naar de eerste positie van het tweede bereik waarvan de elementen moeten worden uitgewisseld.

Retourwaarde

Een doorstuurserver die verwijst naar één na de laatste positie van het tweede bereik waarvan de elementen moeten worden uitgewisseld.

Opmerkingen

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie. Het tweede bereik moet zo groot zijn als het eerste bereik.

De complexiteit is lineair met de laatste 1 - eerste1 wisselingen uitgevoerd. Als elementen van containers van hetzelfde type worden verwisseld, moet de swap lidfunctie van die container worden gebruikt, omdat de lidfunctie doorgaans constante complexiteit heeft.

Voorbeeld

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

Hiermee past u een opgegeven functieobject toe op elk element in een bronbereik of op een paar elementen uit twee bronbereiken. Vervolgens worden de retourwaarden van het functieobject gekopieerd naar een doelbereik.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first1
Een invoer-iterator die de positie van het eerste element in het eerste bronbereik aangeeft waarop moet worden gewerkt.

last1
Een invoer-iterator die de positie na het laatste element in het eerste bronbereik aangeeft waarop moet worden gewerkt.

first2
Een invoer-iterator die de positie van het eerste element in het tweede bronbereik aangeeft waarop moet worden gewerkt.

result
Een uitvoer-iterator die de positie van het eerste element in het doelbereik aanpakt.

func
Door de gebruiker gedefinieerd unaire functieobject dat wordt gebruikt in de eerste versie van het algoritme om toe te passen op elk element in het eerste bronbereik of een door de gebruiker gedefinieerd binair functieobject dat wordt gebruikt in de tweede versie van het algoritme dat paarsgewijs in een voorwaartse volgorde wordt toegepast op de twee bronbereiken.

Retourwaarde

Een uitvoer-iterator die de positie na het laatste element in het doelbereik aanspreekt dat de uitvoerelementen ontvangt die zijn getransformeerd door het functieobject.

Opmerkingen

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deducteerbaar zijn en binnen elke volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie. Het doelbereik moet groot genoeg zijn om het getransformeerde bronbereik te bevatten.

Als het resultaat gelijk is aan first1 in de eerste versie van het algoritme, zijn de bron- en doelbereiken hetzelfde en wordt de volgorde gewijzigd. Maar het result mag geen positie binnen het bereik [first1 + 1, last1).

De complexiteit is lineair. Het maakt maximaal (last1 - first1) vergelijkingen.

Voorbeeld

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

Hiermee verwijdert u dubbele elementen die naast elkaar in een opgegeven bereik staan.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuur iterator die de positie van het eerste element in het bereik adresseren om te worden gescand op dubbele verwijdering.

last
Een doorstuur iterator die de positie na het laatste element in het bereik aanspreekt om te worden gescand op dubbele verwijdering.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een doorstuur iterator naar het nieuwe einde van de gewijzigde reeks die geen opeenvolgende duplicaten bevat, waarbij de positie één voorbij het laatste element niet is verwijderd.

Opmerkingen

Beide vormen van het algoritme verwijderen het tweede duplicaat van een opeenvolgend paar gelijke elementen.

De werking van het algoritme is stabiel, zodat de relatieve volgorde van de niet-verwijderde elementen niet wordt gewijzigd.

Het bereik waarnaar wordt verwezen, moet geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen de volgorde is de laatste positie bereikbaar vanaf de eerste met incrementatie. Het aantal elementen in de reeks wordt niet gewijzigd door het algoritme unique en de elementen buiten het einde van de gewijzigde reeks zijn deducteerbaar, maar niet opgegeven.

De complexiteit is lineair, waarvoor vergelijkingen nodig zijn (last - first) - 1 .

De lijst biedt een efficiëntere lidfunctie 'uniek', wat mogelijk beter presteert.

Deze algoritmen kunnen niet worden gebruikt voor een associatieve container.

Voorbeeld

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

Kopieert elementen uit een bronbereik naar een doelbereik, met uitzondering van de dubbele elementen die naast elkaar staan.

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

Parameterwaarden

exec
Het uitvoeringsbeleid dat moet worden gebruikt.

first
Een doorstuurserver die de positie van het eerste element in het bronbereik adresseren dat moet worden gekopieerd.

last
Een doorstuur-iterator die de positie na het laatste element in het bronbereik heeft om te worden gekopieerd.

result
Een uitvoer-iterator die de positie adresseert van het eerste element in het doelbereik dat de kopie ontvangt met opeenvolgende duplicaten die zijn verwijderd.

pred
Door de gebruiker gedefinieerd predicaatfunctieobject dat de voorwaarde definieert waaraan moet worden voldaan als twee elementen als gelijkwaardig moeten worden beschouwd. Een binair predicaat heeft twee argumenten en retourneert true wanneer tevreden en false wanneer niet is voldaan.

Retourwaarde

Een uitvoer-iterator die de positie één voorbij het laatste element in het doelbereik heeft, waarbij de kopie wordt ontvangen met opeenvolgende duplicaten die zijn verwijderd.

Opmerkingen

Beide vormen van het algoritme verwijderen het tweede duplicaat van een opeenvolgend paar gelijke elementen.

De werking van het algoritme is stabiel, zodat de relatieve volgorde van de niet-verwijderde elementen niet wordt gewijzigd.

De bereiken waarnaar wordt verwezen, moeten geldig zijn; alle aanwijzers moeten deductiebaar zijn en binnen een reeks is de laatste positie bereikbaar vanaf de eerste door incrementatie.

De complexiteit is lineair en vereist (last - first) vergelijkingen.

Voorbeeld

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

Hiermee zoekt u de positie van het eerste element in een geordende bereik met een waarde die groter is dan een opgegeven waarde. Een binair predicaat geeft het bestelcriterium aan.

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

Parameterwaarden

first
De positie van het eerste element in het bereik dat moet worden doorzocht.

last
De positie voorbij het laatste element in het bereik dat moet worden doorzocht.

value
De waarde in het geordende bereik dat moet worden overschreden door de waarde van het element dat door de iterator is geretourneerd.

pred
Door de gebruiker gedefinieerd vergelijkingspredicaatfunctieobject dat het gevoel definieert waarin het ene element kleiner is dan een ander element. Een vergelijkingspredicaat heeft twee argumenten en retourneert true wanneer er wordt voldaan en false wanneer niet is voldaan.

Retourwaarde

Een doorstuurserver naar de positie van het eerste element met een waarde die groter is dan een opgegeven waarde.

Opmerkingen

Het gesorteerde bronbereik waarnaar wordt verwezen, moet geldig zijn; alle iterators moeten deducteerbaar zijn en binnen de volgorde moet de laatste positie bereikbaar zijn vanaf de eerste door incrementatie.

Een gesorteerd bereik is een voorwaarde voor het gebruik van upper_bound en waarbij het rangordecriterium hetzelfde is als opgegeven door het vergelijkingspredicaat.

Het bereik wordt niet gewijzigd door upper_bound.

De waardetypen van de doorstuurservers moeten kleiner zijn dan vergelijkbaar met geordende volgorde. Op basis van twee elementen kunt u bepalen of de ene kleiner is dan de andere, of dat ze gelijkwaardig zijn. (Hier betekent equivalent dat geen van beide minder is dan de andere.) Deze vergelijking resulteert in een volgorde tussen de nonequivalente elementen.

De complexiteit van het algoritme is logaritmisch voor iterators voor willekeurige toegang en lineair, met het aantal stappen proportioneel aan (last - first).

Voorbeeld

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