<algorithm> funktioner

Rubriken <algorithm> innehåller följande funktioner:

adjacent_find

Söker efter två intilliggande element som antingen är lika med eller uppfyller ett angivet villkor.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator vid positionen för det första elementet i intervallet som ska sökas igenom.

last
En vidarebefordrande iterator på positionen en förbi det sista elementet i intervallet som ska sökas igenom.

pred
Det binära predikatet som ger villkoret att uppfyllas av värdena för de intilliggande elementen i området som genomsöks.

Returvärde

En vidarebefordrande iterator till det första av de intilliggande elementen som antingen är lika med varandra (i den första versionen) eller som uppfyller villkoret som anges av det binära predikatet (i den andra versionen) om ett sådant elementpar hittas. Annars returneras en iterator som pekar på last .

Anmärkningar

Algoritmen adjacent_find är en icke-muterande sekvensalgoritm. Det område som ska sökas igenom måste vara giltigt. Alla pekare måste vara avrefererbara och den sista positionen måste kunna nås från den första genom inkrementering. Tidskomplexiteten för algoritmen är linjär i antalet element som finns i intervallet.

Den operator== som används för att fastställa matchningen mellan element måste införa en ekvivalensrelation mellan dess operander.

Exempel

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

Returnerar true när ett villkor finns i varje element i det angivna intervallet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator för indata som anger var du ska börja söka efter ett villkor. Iteratorn markerar var ett område med element börjar.

last
En indata-iterator som anger slutet på elementintervallet för att söka efter ett villkor.

pred
Ett villkor att testa för. pred är ett användardefinierat unary predicate-funktionsobjekt som definierar villkoret som ska uppfyllas av ett element som kontrolleras. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

Returnerar true om villkoret identifieras vid varje element i det angivna intervallet eller om intervallet är tomt och false på annat sätt.

Anmärkningar

Mallfunktionen returnerar true endast om predikatet pred(*(first + N)) för var och en N i intervallet [0, last - first)är true.

Exempel

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

Returnerar true när ett villkor finns minst en gång i det angivna elementintervallet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som anger var du ska börja kontrollera ett område med element för ett villkor.

last
En indata-iterator som anger slutet på elementintervallet för att söka efter ett villkor.

pred
Ett villkor att testa för. Det här testet tillhandahålls av ett användardefinierat predikatfunktionsobjekt. Predikatet definierar villkoret som ska uppfyllas av elementet som testas. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

Returnerar true om villkoret identifieras minst en gång i det angivna intervallet, false om villkoret aldrig identifieras.

Anmärkningar

Mallfunktionen returnerar true endast om för vissa N i intervallet

[0, last - first)är predikatet pred(*(first + N)) sant.

Exempel

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

Testar om det finns ett element i ett sorterat intervall som är lika med ett angivet värde eller som motsvarar det i en mening som anges av ett binärt predikat.

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

Parameterar

first
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas igenom.

value
Det värde som krävs för att matchas av värdet för elementet eller som måste uppfylla villkoret med det elementvärde som anges av det binära predikatet.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

trueom ett element hittas i intervallet som är lika med eller likvärdigt med det angivna värdet; annars . false

Anmärkningar

Det sorterade källintervallet som refereras måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen måste den sista positionen kunna nås från den första genom inkrementering.

Det sorterade intervallet måste ordnas som en förutsättning för algoritmens binary_search tillämpning i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen.

Källintervallen ändras inte av binary_search.

Värdetyperna för vidarebefordrade iteratorer måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen.

Algoritmens komplexitet är logaritmisk för iteratorer med slumpmässig åtkomst och linjärt annars, med antalet steg proportionella mot (last-first).

Exempel

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

Jämför ett värde med en övre och nedre gräns och returnerar en referens till värdet om det är mellan gränserna, eller en referens till den övre eller nedre gränsen om värdet är över respektive under dem.

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

Parameterar

value
Värdet som ska jämföras med upper och lower.

lower
Den lägre gränsen för värden att klämma value till.

upper
Den övre gränsen för värden att klämma till value .

pred
Ett predikat som används för att lower jämföra med value eller upper. Ett jämförelsepredikat tar två argument och returnerar true om det första i någon mening är mindre än det andra, och annars false.

Returvärde

Returnerar en referens till lower om value < lower, eller en referens till upper om upper < value. Annars returneras en referens till value.

Anmärkningar

Beteendet är odefinierat om upper det är mindre än lower.

copy

Tilldelar värdena för element från ett källintervall till ett målintervall, itererar genom källsekvensen av element och tilldelar dem nya positioner i framåtriktad riktning.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som hanterar positionen för det första elementet i källintervallet.

last
En indata iterator som hanterar positionen som är en förbi det sista elementet i källintervallet.

destBeg
En iterator för utdata som hanterar positionen för det första elementet i målintervallet.

Returvärde

En iterator för utdata som adresserar positionen som är en förbi det sista elementet i målintervallet, det vill:s iteratoradresser result + ( - lastfirst).

Anmärkningar

Källintervallet måste vara giltigt och det måste finnas tillräckligt med utrymme på målet för att alla element som kopieras ska kunna lagras.

Eftersom algoritmen kopierar källelementen i ordning från och med det första elementet kan målintervallet överlappa källintervallet förutsatt att last källintervallets position inte finns i målintervallet. copy kan användas för att flytta element till vänster men inte åt höger, såvida det inte finns någon överlappning mellan käll- och målintervallen. Om du vill flytta till rätt antal positioner använder du algoritmen copy_backward .

Algoritmen copy ändrar bara värden som iteratorerna pekar på och tilldelar nya värden till element i målintervallet. Det kan inte användas för att skapa nya element och kan inte infoga element i en tom container direkt.

Exempel

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

Tilldelar värdena för element från ett källintervall till ett målintervall, itererar genom källsekvensen av element och tilldelar dem nya positioner i bakåtriktad riktning.

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

Parameterar

first
En dubbelriktad iterator som hanterar positionen för det första elementet i källintervallet.

last
En dubbelriktad iterator som hanterar positionen som är en förbi det sista elementet i källintervallet.

destEnd
En dubbelriktad iterator som hanterar positionen för en förbi det sista elementet i målintervallet.

Returvärde

En iterator för utdata som adresserar positionen som är en efter det sista elementet i målintervallet, det vill: iteratorn adresserar destEnd - (last - first).

Anmärkningar

Källintervallet måste vara giltigt och det måste finnas tillräckligt med utrymme på målet för att alla element som kopieras ska kunna lagras.

Algoritmen copy_backward ställer strängare krav än algoritmen copy . Både dess indata- och utdata-iteratorer måste vara dubbelriktade.

copy_backward Algoritmerna och move_backward är de enda C++ Standard Library-algoritmerna som anger utdataintervallet med en iterator som pekar mot slutet av målintervallet.

Eftersom algoritmen kopierar källelementen i ordning från och med det sista elementet kan målintervallet överlappa källintervallet förutsatt att first källintervallets position inte finns i målintervallet. copy_backward kan användas för att flytta element till höger men inte till vänster, såvida det inte finns någon överlappning mellan käll- och målintervallen. Om du vill flytta till vänster valfritt antal positioner använder du algoritmen copy .

Algoritmen copy_backward ändrar bara värden som iteratorerna pekar på och tilldelar nya värden till element i målintervallet. Det kan inte användas för att skapa nya element och kan inte infoga element i en tom container direkt.

Exempel

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

I ett område med element kopieras de element som är true för det angivna villkoret.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som anger början av ett intervall för att söka efter villkoret.

last
En indata iterator som anger slutet av intervallet.

dest
Utdata-iteratorn som anger målet för de kopierade elementen.

pred
Villkoret som varje element i intervallet testas mot. Det här villkoret tillhandahålls av ett användardefinierat predikatfunktionsobjekt. Ett unary predikat tar ett argument och returnerar true eller false.

Returvärde

En iterator för utdata som är lika dest med inkrementerad en gång för varje element som uppfyller villkoret. Med andra ord är returvärdet minus dest lika med antalet kopierade element.

Anmärkningar

Mallfunktionen utvärderas

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

en gång för varje N i intervallet [0, last - first), för strikt ökande värden för N att börja med det lägsta värdet. Om dest och first ange lagringsregioner dest får det inte finnas i intervallet [ first, last ).

Exempel

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

Kopierar ett angivet antal element.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator för indata som anger var elementen ska kopieras från.

count
En signerad eller osignerad heltalstyp som anger antalet element som ska kopieras.

dest
En iterator för utdata som anger var elementen ska kopieras till.

Returvärde

Returnerar en utdata iterator där element har kopierats till. Det är samma som det returnerade värdet för parametern dest .

Anmärkningar

Mallfunktionen utvärderas *(dest + N) = *(first + N)) en gång för var och en N i intervallet [0, count)för att strikt öka värdena N för att börja med det lägsta värdet. Den returnerar dest + Nsedan . Om dest och first ange lagringsregioner dest får det inte finnas i intervallet [first, last).

Exempel

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

Returnerar antalet element i ett intervall vars värden matchar ett angivet värde.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som hanterar positionen för det första elementet i intervallet som ska passeras.

last
En iterator för indata som adresserar positionen förbi det sista elementet i intervallet som ska passeras.

value
Värdet för de element som ska räknas.

Returvärde

Skillnadstypen för InputIterator det som räknar antalet element i intervallet [first, last) som har värdet value.

Anmärkningar

Den operator== som används för att fastställa matchningen mellan ett element och det angivna värdet måste införa en ekvivalensrelation mellan dess operander.

Den här algoritmen generaliseras för att räkna element som uppfyller alla predikat med mallfunktionen count_if.

Exempel

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

Returnerar antalet element i ett intervall vars värden uppfyller ett angivet villkor.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator för indata som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last
En iterator för indata som adresserar positionen förbi det sista elementet i intervallet som ska sökas igenom.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om ett element ska räknas. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

Antalet element som uppfyller villkoret som anges av predikatet.

Anmärkningar

Den här mallfunktionen är en generalisering av algoritmen countoch ersätter predikatet "lika med ett specifikt värde" med alla predikat.

Exempel

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

Jämför två intervallelement efter element för likhet eller likvärdighet i en mening som anges av ett binärt predikat.

Använd std::equal när du jämför element i olika containertyper (till exempel vector och list) eller när du jämför olika elementtyper, eller när du behöver jämföra underlagringar av containrar. När du jämför element av samma typ i samma containertyp använder du annars den icke-medlem operator== som tillhandahålls för varje container.

Använd överlagringar med dubbla intervall i C++14-koden eftersom överlagringarna som bara tar en enskild iterator för det andra intervallet inte identifierar skillnader om det andra intervallet är längre än det första intervallet. Dessa överlagringar resulterar i odefinierat beteende om det andra intervallet är kortare än det första intervallet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata-iterator som hanterar positionen för det första elementet i det första intervallet som ska testas.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första intervallet som ska testas.

first2
En iterator för indata som hanterar positionen för det första elementet i det andra intervallet som ska testas.

last2
En indata iterator som hanterar positionen för ett förbi det sista elementet i det andra intervallet som ska testas.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

trueom och endast om intervallen är identiska eller likvärdiga under det binära predikatet vid jämförelse av element per element; annars . false

Anmärkningar

Det område som ska sökas igenom måste vara giltigt. alla iteratorer måste vara avrefererbara och den sista positionen kan nås från den första genom inkrementering.

Om de två intervallen är lika långa är algoritmens tidskomplexitet linjär i antalet element som ingår i intervallet. Annars returnerar falsefunktionen omedelbart .

Du behöver inte någon av operator== eller det användardefinierade predikatet för att införa en ekvivalensrelation som är symmetrisk, reflexiv och transitiv mellan dess operander.

Exempel

#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

Givet ett ordnat intervall hittar du underordningen där alla element motsvarar ett angivet värde.

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

Parameterar

first
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas igenom.

value
Det värde som söks efter i det ordnade intervallet.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Ett jämförelsepredikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

Ett par vidarebefordrade iteratorer som anger ett underområde som finns inom det sökta intervallet, där alla element är likvärdiga value med i den mening som definieras av det binära predikat som används (antingen pred eller standardvärdet, mindre än).

Om inga element i intervallet motsvarar är de vidarebefordrade iteratorerna i det returnerade paret lika och anger den punkt där value det går att infoga utan att valuestöra intervallets ordning.

Anmärkningar

Den första iteratorn för paret som returneras av algoritmen är lower_bound, och den andra iteratorn är upper_bound.

Intervallet måste sorteras enligt predikatet som anges i equal_range. Om du till exempel ska använda predikatet större än predikatet måste intervallet sorteras i fallande ordning.

Element i det eventuellt tomma underintervallet som definieras av de par iteratorer som returneras av equal_range motsvarar värdet i den mening som definieras av predikatet som används.

Algoritmens komplexitet är logaritmisk för iteratorer med slumpmässig åtkomst och linjärt annars, med antalet steg proportionella mot (last - first).

Exempel

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

Tilldelar samma nya värde till varje element i ett angivet intervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som hanterar positionen för det första elementet i intervallet som ska passeras.

last
En vidarebefordran iterator som adresserar positionen en förbi det sista elementet i intervallet som ska passeras.

value
Värdet som ska tilldelas till element i intervallet [first, last).

Anmärkningar

Målintervallet måste vara giltigt. alla pekare måste vara avrefererbara och den sista positionen kan nås från den första genom inkrementering. Komplexiteten är linjär med intervallets storlek.

Exempel

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

Tilldelar ett nytt värde till ett angivet antal element i ett intervall som börjar med ett visst 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);

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator för utdata som hanterar positionen för det första elementet i intervallet som ska tilldelas värdet value.

count
En signerad eller osignerad heltalstyp som anger antalet element som ska tilldelas värdet.

value
Värdet som ska tilldelas till element i intervallet [first, first + count).

Returvärde

En iterator till elementet som följer det sista elementet fyllt om count> noll, annars det första elementet.

Anmärkningar

Målintervallet måste vara giltigt. alla pekare måste vara avrefererbara och den sista positionen kan nås från den första genom inkrementering. Komplexiteten är linjär med intervallets storlek.

Exempel

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

Letar upp positionen för den första förekomsten av ett element i ett intervall som har ett angivet värde.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indataiterator som adresserar positionen för det första elementet i intervallet som ska sökas efter det angivna värdet.

last
En indataiterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas efter det angivna värdet.

value
Det värde som ska sökas efter.

Returvärde

En indataiterator som hanterar den första förekomsten av det angivna värdet i det intervall som genomsöks. Om inget element hittas med ett motsvarande värde returnerar last.

Anmärkningar

Den operator== som används för att fastställa matchningen mellan ett element och det angivna värdet måste införa en ekvivalensrelation mellan dess operander.

Ett kodexempel som använder finns find()i find_if.

find_end

Söker i ett intervall efter den sista underfrågan som är identisk med en angiven sekvens eller som är likvärdig i en mening som anges av ett binärt predikat.

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

Parameterar

first1
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last1
En vidarebefordrande iterator som adresserar positionen förbi det sista elementet i intervallet som ska sökas igenom.

first2
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet att söka efter.

last2
En vidarebefordran iterator som adresserar positionen förbi det sista elementet i intervallet att söka efter.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En vidarebefordrande iterator som hanterar positionen för det första elementet i den sista underfrågan inom [first1, last1) som matchar den angivna sekvensen [first2, last2).

Anmärkningar

Den operator== som används för att fastställa matchningen mellan ett element och det angivna värdet måste införa en ekvivalensrelation mellan dess operander.

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens kan den sista positionen nås från den första genom inkrementering.

Exempel

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

Söker efter den första förekomsten av något av flera värden inom ett målintervall. Eller söker efter den första förekomsten av något av flera element som är likvärdiga i en mening som anges av ett binärt predikat till en angiven uppsättning element.

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

Parameterar

first1
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last1
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas igenom.

first2
En vidarebefordran iterator som hanterar positionen för det första elementet i intervallet som ska matchas.

last2
En vidarebefordran iterator som adresserar positionen en förbi det sista elementet i intervallet som ska matchas.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En vidarebefordrande iterator som hanterar positionen för det första elementet i den första underfrågan som matchar den angivna sekvensen eller som är likvärdig i en mening som anges av ett binärt predikat.

Anmärkningar

Den operator== som används för att fastställa matchningen mellan ett element och det angivna värdet måste införa en ekvivalensrelation mellan dess operander.

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens kan den sista positionen nås från den första genom inkrementering.

Exempel

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

Letar upp positionen för den första förekomsten av ett element i ett intervall som uppfyller ett angivet villkor.

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

Parameterar

first
En iterator för indata som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last
En iterator för indata som adresserar positionen förbi det sista elementet i intervallet som ska sökas igenom.

pred
Användardefinierat predikatfunktionsobjekt eller lambda-uttryck som definierar villkoret som ska uppfyllas av elementet som söks efter. Ett unary-predikat tar ett enda argument och returnerar true om det är uppfyllt, eller false om det inte är uppfyllt. Signaturen pred för måste i praktiken vara bool pred(const T& arg);, där T är en typ som InputIterator kan konverteras implicit när dereferenced. Nyckelordet const visas bara för att illustrera att funktionsobjektet eller lambda inte ska ändra argumentet.

Returvärde

En indataiterator som refererar till det första elementet i intervallet som uppfyller villkoret som anges av predikatet (predikatet resulterar i true). Om inget element hittas för att uppfylla predikatet returnerar last.

Anmärkningar

Den här mallfunktionen är en generalisering av algoritmen findoch ersätter predikatet "lika med ett specifikt värde" med alla predikat. Den logiska motsatsen (hitta det första elementet som inte uppfyller predikatet) find_if_notfinns i .

Exempel

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

Returnerar det första elementet i det angivna intervallet som inte uppfyller ett villkor.

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

Parameterar

first
En iterator för indata som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last
En iterator för indata som adresserar positionen förbi det sista elementet i intervallet som ska sökas igenom.

pred
Användardefinierat predikatfunktionsobjekt eller lambda-uttryck som definierar villkoret som inte uppfylls av elementet som söks efter. Ett unary-predikat tar ett enda argument och returnerar true om det är uppfyllt, eller false om det inte är uppfyllt. Signaturen pred för måste i praktiken vara bool pred(const T& arg);, där T är en typ som InputIterator kan konverteras implicit när dereferenced. Nyckelordet const visas bara för att illustrera att funktionsobjektet eller lambda inte ska ändra argumentet.

Returvärde

En indataiterator som refererar till det första elementet i intervallet som inte uppfyller villkoret som anges av predikatet (predikatet resulterar i false). Om alla element uppfyller predikatet (predikatet resulterar i true för varje element) returnerar last.

Anmärkningar

Den här mallfunktionen är en generalisering av algoritmen findoch ersätter predikatet "lika med ett specifikt värde" med alla predikat. Den logiska motsatsen (hitta det första elementet som uppfyller predikatet) finns find_ifi .

Ett kodexempel som är lätt att anpassa till find_if_not()finns i find_if.

for_each

Tillämpar ett angivet funktionsobjekt på varje element i framåtordning inom ett intervall och returnerar funktionsobjektet.

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

Parameterar

first
En iterator för indata som hanterar positionen för det första elementet i intervallet som ska användas.

last
En indata iterator som hanterar positionen en förbi det sista elementet i intervallet som körs på.

func
Användardefinierat funktionsobjekt som tillämpas på varje element i intervallet.

Returvärde

En kopia av funktionsobjektet när det har tillämpats på alla element i intervallet.

Anmärkningar

Algoritmen for_each är flexibel, vilket gör det möjligt att ändra varje element inom ett intervall på olika, användardefinierade sätt. Templaterade funktioner kan återanvändas i ett modifierat formulär genom att skicka olika parametrar. Användardefinierade funktioner kan samla in information i ett internt tillstånd som algoritmen kan returnera efter bearbetning av alla element i intervallet.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen måste den sista positionen kunna nås från den första genom inkrementering.

Komplexiteten är linjär med högst (last - first) jämförelser.

Exempel

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

Tillämpar ett angivet funktionsobjekt på ett angivet antal element i ett intervall som börjar med ett visst 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);

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator vid positionen för det första elementet i intervallet som ska köras på.

count
Antalet element som ska användas.

func
Ett användardefinierat funktionsobjekt som ska tillämpas på varje element i intervallet [first, first + count).

Returvärde

En iterator till elementet som följer det sista elementet som bearbetas om count> noll, annars det första elementet.

Anmärkningar

count måste vara icke-negativ och det måste finnas minst count element i intervallet från first.

Exempel

Det här exemplet definierar en funktionsobjektklass. Produktionskoden använder ofta en lambda för att uppnå samma resultat med mindre kod.

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

Tilldelar de värden som genereras av ett funktionsobjekt till varje element i ett intervall.

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

Parameterar

first
En vidarebefordrande iterator vid positionen för det första elementet i intervallet som värden ska tilldelas till.

last
En vidarebefordrande iterator på positionen en förbi det sista elementet i intervallet som värden ska tilldelas till.

gen
Ett funktionsobjekt som anropas utan argument för att generera de värden som ska tilldelas till vart och ett av elementen i intervallet.

Anmärkningar

Funktionsobjektet anropas för varje element i intervallet och behöver inte returnera samma värde varje gång det anropas. Den kan till exempel läsa från en fil eller referera till och ändra ett lokalt tillstånd. Generatorns resultattyp måste konverteras till värdetypen för vidarebefordraren för intervallet.

Det angivna intervallet måste vara giltigt. Alla pekare måste vara avrefererbara och inom sekvensen måste den sista positionen kunna nås från den första genom inkrementering.

Komplexiteten är linjär, med exakt last - first anrop till generatorn.

Exempel

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

Tilldelar de värden som genereras av ett funktionsobjekt till ett angivet antal element i ett intervall. Returnerar positionen en efter det senast tilldelade värdet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En utdata-iterator som hanterar positionen för det första elementet i intervallet som värden ska tilldelas till.

count
En signerad eller osignerad heltalstyp som anger antalet element som ska tilldelas ett värde av generatorfunktionen.

gen
Ett funktionsobjekt som anropas utan argument som används för att generera de värden som ska tilldelas till vart och ett av elementen i intervallet.

Anmärkningar

Funktionsobjektet anropas för varje element i intervallet och behöver inte returnera samma värde varje gång det anropas. Den kan till exempel läsa från en fil eller referera till och ändra ett lokalt tillstånd. Generatorns resultattyp måste konverteras till värdetypen för vidarebefordrade iteratorer för intervallet.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen måste den sista positionen kunna nås från den första genom inkrementering.

Komplexiteten är linjär, med exakt count anrop till generatorn som krävs.

Exempel

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

Testar om ett sorterat område innehåller alla element som finns i ett andra sorterat område, där kriteriet för ordning eller likvärdighet mellan element kan anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata-iterator som hanterar positionen för det första elementet i det första av två sorterade källintervall som ska testas för huruvida alla element i det andra finns i det första.

last1
En indata iterator som hanterar positionen ett förbi det sista elementet i det första av två sorterade källintervall som ska testas för huruvida alla element i den andra finns i den första.

first2
En indata-iterator som hanterar positionen för det första elementet i andra av två på varandra följande sorterade källintervall som ska testas för huruvida alla element i det andra finns i det första.

last2
En indata iterator som hanterar positionen ett förbi det sista elementet i andra av två på varandra följande sorterade källintervall som ska testas för huruvida alla element i den andra finns i den första.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett jämförelsepredikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

trueom det första sorterade intervallet innehåller alla element i det andra sorterade intervallet. annars . false

Anmärkningar

Ett annat sätt att tänka på det här testet är att det fastställde om det andra källintervallet är en delmängd av det första källintervallet.

De sorterade källintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Som en förutsättning för tillämpningen av algoritmen includesmåste de sorterade källintervallen ordnas med samma ordning som används av algoritmen för att sortera de kombinerade intervallen.

Källintervallen ändras inte av algoritmen merge.

Värdetyperna för indata-iteratorerna måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen. Mer exakt testar algoritmen om alla element i det första sorterade intervallet under ett angivet binärt predikat har motsvarande ordning som de i det andra sorterade intervallet.

Komplexiteten i algoritmen är linjär med som mest 2 * ((last1 - first1) + (last2 - first2)) - 1 jämförelser för icke-snåla källintervall.

Exempel

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

Kombinerar elementen från två på varandra följande sorterade intervall till ett enda sorterat område, där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En dubbelriktad iterator som hanterar positionen för det första elementet i det första av två sorterade intervall i följd som ska kombineras och sorteras i ett enda intervall.

middle
En dubbelriktad iterator som hanterar positionen för det första elementet i det andra av två på varandra följande sorterade intervall som ska kombineras och sorteras i ett enda intervall.

last
En dubbelriktad iterator som adresserar positionen förbi det sista elementet i det andra av två sorterade intervall i följd som ska kombineras och sorteras i ett enda intervall.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Jämförelsepredikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet och false på annat sätt.

Anmärkningar

De sorterade intervallen i följd som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Sorterade intervall i följd måste vara ordnade som en förutsättning för algoritmens inplace_merge tillämpning i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen. Åtgärden är stabil eftersom den relativa ordningen för element inom varje intervall bevaras. När det finns motsvarande element i båda källintervallen, är elementet det första intervallet föregår elementet från det andra i det kombinerade intervallet.

Komplexiteten beror på det tillgängliga minnet eftersom algoritmen allokerar minne till en tillfällig buffert. Om tillräckligt med minne är tillgängligt är det bästa fallet linjärt med (last - first) - 1 jämförelser. Om det inte finns något extra minne är det värsta fallet N log(N), där Nfirst = last - .

Exempel

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

Returnerar true om elementen i det angivna intervallet bildar en heap.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator för slumpmässig åtkomst som anger början av ett intervall för att söka efter en heap.

last
En iterator för slumpmässig åtkomst som anger slutet på ett intervall.

pred
Ett villkor för att testa för att beställa element. Ett jämförelsepredikat tar två argument och returnerar true eller false.

Returvärde

Returnerar true om elementen i det angivna intervallet bildar en heap, false om de inte gör det.

Anmärkningar

Den första mallfunktionen returnerar is_heap_until(first , last) == last.

Den andra mallfunktionen returnerar

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

is_heap_until

Returnerar en iterator placerad vid det första elementet i intervallet [ first, last) som inte uppfyller heapordningsvillkoret, eller end om intervallet utgör en heap.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator för slumpmässig åtkomst som anger det första elementet i ett intervall för att söka efter en heap.

last
En iterator för slumpmässig åtkomst som anger slutet av intervallet för att söka efter en heap.

pred
Ett binärt predikat som anger det strikta svaga ordningsvillkor som definierar en heap. Standardpredikatet är std::less<> när pred inte har angetts.

Returvärde

Returnerar last om det angivna intervallet bildar en heap eller innehåller ett eller färre element. Annars returnerar en iterator för det första elementet som hittades som inte uppfyller heap-villkoret.

Anmärkningar

Den första mallfunktionen returnerar den sista iteratorn next där [first, next)[first, last) är en heap ordnad av funktionsobjektet std::less<>. Om avståndet last - first är mindre än 2 returnerar lastfunktionen .

Den andra mallfunktionen fungerar på samma sätt som den första, förutom att den använder predikatet pred i stället för std::less<> som heapordningsvillkoret.

is_partitioned

Returnerar true om alla element i det angivna intervallet som testar true för ett villkor kommer före alla element som testar 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);

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata-iterator som anger var ett intervall börjar söka efter ett villkor.

last
En indata-iterator som anger slutet på ett intervall.

pred
Villkoret att testa för. Det här testet tillhandahålls av ett användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas av elementet som söks efter. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

Returnerar true när alla element i det angivna intervallet som testar true för ett villkor kommer före alla element som testar false, och annars returnerar false.

Anmärkningar

Mallfunktionen returnerar true endast om alla element i [first, last) partitioneras av pred, dvs. alla element X som [first, last)pred (X) är sanna inträffar innan alla element Y som pred (Y) är false.

is_permutation

Returnerar true om båda intervallen innehåller samma element, oavsett om elementen är i samma ordning eller inte. Använd överlagringar med dubbla intervall i C++14-koden eftersom överlagringarna som bara tar en enskild iterator för det andra intervallet inte identifierar skillnader om det andra intervallet är längre än det första intervallet. Dessa överlagringar resulterar i odefinierat beteende om det andra intervallet är kortare än det första intervallet.

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

Parameterar

first1
En vidarebefordrant iterator som refererar till det första elementet i intervallet.

last1
En vidarebefordran iterator som refererar en förbi det sista elementet i intervallet.

first2
En vidarebefordran iterator som refererar till det första elementet i ett andra intervall, som används för jämförelse.

last2
En vidarebefordran iterator som refererar till en förbi det sista elementet i ett andra intervall, som används för jämförelse.

pred
Ett predikat som testar för likvärdighet och returnerar en bool.

Returvärde

truenär intervallen kan ordnas om så att de är identiska enligt jämförelsepredikatet. annars . false

Anmärkningar

is_permutation har kvadratisk komplexitet i värsta fall.

Den första mallfunktionen förutsätter att det finns lika många element i intervallet som börjar på first2 som det finns i intervallet som anges av [first1, last1). Om det finns fler element i det andra intervallet ignoreras de. Om det finns mindre, kommer odefinierat beteende att inträffa. Den tredje mallfunktionen (C++14 och senare) gör inte det här antagandet. Båda returnerar true endast om för varje element X i intervallet som anges av [first1, last1) det finns lika många element Y i samma intervall som X == Y det finns i intervallet som börjar på first2 eller [first2, last2). operator== Här måste du göra en parvis jämförelse mellan dess operander.

Den andra och fjärde mallen fungerar likadant, förutom att de ersätter operator==(X, Y) med Pred(X, Y). För att fungera korrekt måste predikatet vara symmetriskt, reflexivt och transitivt.

Exempel

I följande exempel visas hur du använder is_permutation:

#include <vector>
#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

int main()
{
    vector<int> vec_1{ 2, 3, 0, 1, 4, 5 };
    vector<int> vec_2{ 5, 4, 0, 3, 1, 2 };

    vector<int> vec_3{ 4, 9, 13, 3, 6, 5 };
    vector<int> vec_4{ 7, 4, 11, 9, 2, 1 };

    cout << "(1) Compare using built-in == operator: ";
    cout << boolalpha << is_permutation(vec_1.begin(), vec_1.end(),
        vec_2.begin(), vec_2.end()) << endl; // true

    cout << "(2) Compare after modifying vec_2: ";
    vec_2[0] = 6;
    cout << is_permutation(vec_1.begin(), vec_1.end(),
        vec_2.begin(), vec_2.end()) << endl; // false

    // Define equivalence as "both are odd or both are even"
    cout << "(3) vec_3 is a permutation of vec_4: ";
    cout << is_permutation(vec_3.begin(), vec_3.end(),
        vec_4.begin(), vec_4.end(),
        [](int lhs, int rhs) { return lhs % 2 == rhs % 2; }) << endl; // true

    // Initialize a vector using the 's' string literal to specify a std::string
    vector<string> animals_1{ "dog"s, "cat"s, "bird"s, "monkey"s };
    vector<string> animals_2{ "donkey"s, "bird"s, "meerkat"s, "cat"s };

    // Define equivalence as "first letters are equal":
    bool is_perm = is_permutation(animals_1.begin(), animals_1.end(), animals_2.begin(), animals_2.end(),
        [](const string& lhs, const string& rhs)
    {
        return lhs[0] == rhs[0]; //std::string guaranteed to have at least a null terminator
    });

    cout << "animals_2 is a permutation of animals_1: " << is_perm << endl; // true

    return 0;
}

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

is_sorted

Returnerar true om elementen i det angivna intervallet är i sorterad ordning.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som anger var intervallet som ska kontrolleras börjar.

last
En vidarebefordran iterator som anger slutet på ett intervall.

pred
Villkoret för att testa för att fastställa en ordning mellan två element. Ett jämförelsepredikat tar två argument och returnerar true eller false. Det här predikatet utför samma uppgift som operator<.

Anmärkningar

Den första mallfunktionen returnerar is_sorted_until( first, last ) == last. Funktionen operator< utför orderjämförelsen.

Den andra mallfunktionen returnerar is_sorted_until( first, last , pred ) == last. Predikatfunktionen pred utför ordningsjämförelsen.

is_sorted_until

Returnerar ett ForwardIterator som är inställt på det sista elementet som är i sorterad ordning från ett angivet intervall.

Med den andra versionen kan du ange ett jämförelsefunktionsobjekt som returneras true när två givna element är i sorterad ordning och false i övrigt.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som anger var intervallet som ska kontrolleras börjar.

last
En vidarebefordran iterator som anger slutet på ett intervall.

pred
Villkoret för att testa för att fastställa en ordning mellan två element. Ett jämförelsepredikat tar två argument och returnerar true eller false.

Returvärde

Returnerar en ForwardIterator uppsättning till det sista elementet i sorterad ordning. Den sorterade sekvensen börjar från first.

Anmärkningar

Den första mallfunktionen returnerar den sista iteratorn next i så att [first, next) är en sorterad sekvens sorterad efter operator<[first, last] . Om distance() är mindre än 2 returnerar lastfunktionen .

Den andra mallfunktionen fungerar på samma sätt, förutom att den ersätter operator<(X, Y) med pred(X, Y).

iter_swap

Utbyter två värden som anges av ett par angivna iteratorer.

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

Parameterar

left
En av de vidarebefordrande iteratorer vars värde ska bytas ut.

right
Den andra av de vidarebefordrande iteratorer vars värde ska bytas ut.

Anmärkningar

swap bör användas i stället för iter_swap, som ingick i C++ Standard för bakåtkompatibilitet. Om Fit1 och Fit2 är vidarebefordrande iteratorer iter_swap( Fit1, Fit2 )motsvarar swap( *Fit1, *Fit2 ), .

Värdetyperna för vidarebefordrande iteratorer för indata måste ha samma värde.

Exempel

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

Jämför element efter element mellan två sekvenser för att avgöra vilket som är mindre av de två.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i det första intervallet som ska jämföras.

last1
En indata iterator som hanterar positionen en förbi det sista elementet i det första intervallet som ska jämföras.

first2
En indata-iterator som hanterar positionen för det första elementet i det andra intervallet som ska jämföras.

last2
En indata iterator som hanterar positionen en förbi det sista elementet i det andra intervallet som ska jämföras.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett jämförelsepredikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

true om det första intervallet är lexicographically mindre än det andra intervallet; annars false.

Anmärkningar

En lexicographical jämförelse mellan sekvenser jämför dem element för element tills:

• Den finner två motsvarande element ojämlika, och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan sekvenser.

• Det finns inga skillnader, men den ena sekvensen har fler element än den andra, och den kortare sekvensen anses vara mindre än den längre sekvensen.

• Inga skillnader hittas och sekvenserna har samma antal element, så sekvenserna är lika och resultatet av jämförelsen är false.

Exempel

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

Hittar positionen för det första elementet i ett ordnat intervall som har ett värde som är större än eller likvärdigt med ett angivet värde. Beställningskriteriet kan anges av ett binärt predikat.

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

Parameterar

first
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas igenom.

value
Värdet vars första position eller möjliga första position söks efter i det ordnade intervallet.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En vidarebefordrande iterator vid positionen för det första elementet i ett ordnat intervall med ett värde som är större än eller likvärdigt med ett angivet värde. Ekvivalensen kan anges med ett binärt predikat.

Anmärkningar

Det sorterade källintervallet som refereras måste vara giltigt. alla iteratorer måste vara avrefererbara och inom sekvensen måste den sista positionen kunna nås från den första genom inkrementering.

Ett sorterat intervall är en förutsättning för att använda lower_bound och där ordningen är densamma som anges av med binär predikat.

Intervallet ändras inte av algoritmen lower_bound.

Värdetyperna för vidarebefordrade iteratorer måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen.

Algoritmens komplexitet är logaritmisk för iteratorer med slumpmässig åtkomst och linjärt annars, med antalet steg proportionella mot (last - first).

Exempel

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

Konverterar element från ett angivet intervall till en heap där det första elementet är det största och för vilket ett sorteringsvillkor kan anges med ett binärt predikat.

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

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

Parameterar

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska konverteras till en heap.

last
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i intervallet som ska konverteras till en heap.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

Heaps har två egenskaper:

• Det första elementet är alltid det största.

• Element kan läggas till eller tas bort i logaritmisk tid.

Heaps är ett idealiskt sätt att implementera prioritetsköer och de används i implementeringen av containeradaptern C++ Standard Library priority_queue Class.

Komplexiteten är linjär och kräver 3 * (last - first) jämförelser.

Exempel

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

Jämför två objekt och returnerar det större av de två, där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

left
Det första av de två objekt som jämförs.

right
Det andra av de två objekt som jämförs.

pred
Ett binärt predikat som används för att jämföra de två objekten.

inlist
Initialiserarlistan som innehåller de objekt som ska jämföras.

Returvärde

Det större av de två objekten, om inte något av dem är större; I så fall returneras det första av de två objekten. När en initializer_list anges returneras det största av objekten i listan.

Anmärkningar

Algoritmen max är ovanlig när objekt skickas som parametrar. De flesta C++ Standard Library-algoritmer fungerar på ett antal element vars position anges av iteratorer som skickas som parametrar. Om du behöver en funktion som fungerar på en mängd olika element använder du max_element i stället. Visual Studio 2017 aktiverar constexpr överlagringarna som tar en initializer_list.

Exempel

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

Hittar den första förekomsten av det största elementet i ett angivet intervall där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som hanterar positionen för det första elementet i intervallet som ska sökas efter det största elementet.

last
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas efter det största elementet.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Jämförelsepredikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet och false på annat sätt.

Returvärde

En vidarebefordran iterator som hanterar positionen för den första förekomsten av det största elementet i det sökta intervallet.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom varje sekvens kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är linjär: (last - first) - 1 jämförelser krävs för ett icke-snålt intervall.

Exempel

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

Kombinerar alla element från två sorterade källintervall till ett enda, sorterat målintervall, där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i det första av två sorterade källintervall som ska kombineras och sorteras i ett enda intervall.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första av två sorterade källintervall som ska kombineras och sorteras i ett enda intervall.

first2
En indata-iterator som hanterar positionen för det första elementet i det andra av två sorterade källintervall i följd som ska kombineras och sorteras i ett enda intervall.

last2
En indata iterator som hanterar positionen ett förbi det sista elementet i andra av två på varandra följande sorterade källintervall som ska kombineras och sorteras i ett enda intervall.

result
En utdata iterator som hanterar positionen för det första elementet i målintervallet där de två källintervallen ska kombineras till ett enda sorterat intervall.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Jämförelsepredikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet, och false i annat fall.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i det sorterade målintervallet.

Anmärkningar

De sorterade källintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Målintervallet bör inte överlappa något av källintervallen och bör vara tillräckligt stort för att innehålla målintervallet.

De sorterade källintervallen måste var och en ordnas som en förutsättning för tillämpningen av algoritmen merge i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen.

Åtgärden är stabil eftersom den relativa ordningen för element inom varje intervall bevaras i målintervallet. Källintervallen ändras inte av algoritmen merge.

Värdetyperna för indata-iteratorerna måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen. När det finns motsvarande element i båda källintervallen föregår elementen i det första intervallet elementen från det andra källintervallet i målintervallet.

Algoritmens komplexitet är linjär med de flesta (last1 - first1) - (last2 - first2) - 1 jämförelser.

Klassenlist tillhandahåller en medlemsfunktion merge för att sammanfoga elementen i två listor.

Exempel

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

Jämför två objekt och returnerar det mindre av de två, där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

left
Det första av de två objekt som jämförs.

right
Det andra av de två objekt som jämförs.

pred
Ett binärt predikat som används för att jämföra de två objekten.

inlist
Det initializer_list som innehåller de medlemmar som ska jämföras.

Returvärde

Det mindre av de två objekten, såvida inte inget av dem är mindre; I så fall returneras det första av de två objekten. När en initializer_list har angetts returneras minst av objekten i listan.

Anmärkningar

Algoritmen min är ovanlig när objekt skickas som parametrar. De flesta C++ Standard Library-algoritmer fungerar på ett antal element vars position anges av iteratorer som skickas som parametrar. Om du behöver en funktion som använder ett antal element använder du min_element. constexpr aktiverades på initializer_list överlagringarna i Visual Studio 2017.

Exempel

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

Hittar den första förekomsten av det minsta elementet i ett angivet intervall där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som hanterar positionen för det första elementet i intervallet som ska sökas efter det minsta elementet.

last
En vidarebefordrande iterator som adresserar positionen förbi det sista elementet i intervallet som ska sökas efter det minsta elementet.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Jämförelsepredikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet, och false i annat fall.

Returvärde

En vidarebefordrande iterator som hanterar positionen för den första förekomsten av det minsta elementet i det sökta intervallet.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom varje sekvens kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är linjär: (last - first) - 1 jämförelser krävs för ett icke-snålt intervall.

Exempel

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

Utför det arbete som utförs av min_element och max_element i ett anrop.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som anger början av ett intervall.

last
En vidarebefordran iterator som anger slutet på ett intervall.

pred
Ett användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Jämförelsepredikatet tar två argument och bör returneras true när det första är mindre än det andra, och false i annat fall.

Returvärde

Retur

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

Anmärkningar

Den första mallfunktionen returnerar

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

Den andra mallfunktionen fungerar på samma sätt, förutom att den ersätter operator<(X, Y) med pred(X, Y).

Om sekvensen inte är tom utför funktionen som mest 3 * (last - first - 1) / 2 jämförelser.

minmax

Jämför två indataparametrar och returnerar dem som ett par, i storleksordningen mindre till större.

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

Parameterar

left
Det första av de två objekt som jämförs.

right
Det andra av de två objekt som jämförs.

pred
Ett binärt predikat som används för att jämföra de två objekten.

inlist
Det initializer_list som innehåller de medlemmar som ska jämföras.

Anmärkningar

Den första mallfunktionen returnerar pair<const Type&, const Type&>( right, left ) om right är mindre än left. Annars returneras pair<const Type&, const Type&>( left, right ).

Den andra medlemsfunktionen returnerar ett par där det första elementet är mindre och det andra är större jämfört med predikatet pred.

De återstående mallfunktionerna fungerar på samma sätt, förutom att de ersätter parametrarna left och right med inlist.

Funktionen utför exakt en jämförelse.

mismatch

Jämför två intervallelement efter element och letar upp den första positionen där en skillnad inträffar.

Använd överlagringar med dubbla intervall i C++14-koden eftersom överlagringarna som bara tar en enskild iterator för det andra intervallet inte identifierar skillnader om det andra intervallet är längre än det första intervallet. Dessa överlagringar resulterar i odefinierat beteende om det andra intervallet är kortare än det första intervallet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata-iterator som hanterar positionen för det första elementet i det första intervallet som ska testas.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första intervallet som ska testas.

first2
En iterator för indata som hanterar positionen för det första elementet i det andra intervallet som ska testas.

last2
En indata iterator som hanterar positionen för ett förbi det sista elementet i det andra intervallet som ska testas.

pred
Användardefinierade predikatfunktionsobjekt som jämför de aktuella elementen i varje intervall och avgör om de är likvärdiga. Den returnerar true när den är nöjd och false inte uppfylld.

Returvärde

Returnerar ett par iteratorer som hanterar positionerna för matchningsfelet i de två intervallen. Den första komponentens iterator pekar på positionen i det första intervallet. Den andra komponentens iterator pekar på positionen i det andra intervallet. Om det inte finns någon skillnad mellan elementen i intervallen jämfört med eller om det binära predikatet i den andra versionen uppfylls av alla elementpar från de två intervallen pekar den första komponentiteratorn på positionen en förbi det sista elementet i det första intervallet och den andra komponentens iterator pekar på en position som ligger förbi det sista elementet som testas i det andra intervallet.

Anmärkningar

Den första mallfunktionen förutsätter att det finns lika många element i intervallet som börjar först2 som det finns i intervallet som anges av [first1, last1). Om det finns fler i det andra intervallet ignoreras de. Om det finns mindre resulterar odefinierat beteende.

Det område som ska sökas igenom måste vara giltigt. alla iteratorer måste vara avrefererbara och den sista positionen kan nås från den första genom inkrementering.

Algoritmens tidskomplexitet är linjär i antalet element som finns i det kortare intervallet.

Det användardefinierade predikatet krävs inte för att införa en ekvivalensrelation som är symmetrisk, reflexiv och transitiv mellan dess operander.

Exempel

I följande exempel visas hur du använder matchningsfel. C++03-överlagringen visas endast för att visa hur den kan ge ett oväntat resultat.

#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

Flytta element som är associerade med ett angivet intervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata-iterator som anger var du ska starta elementintervallet som ska flyttas.

last
En indata-iterator som anger slutet på ett område med element som ska flyttas.

dest
Den utdata iterator som ska innehålla de flyttade elementen.

Anmärkningar

Mallfunktionen utvärderas *(dest + N) = move(*(first + N)) en gång för var och en N i intervallet [0, last - first)för att strikt öka värdena N för att börja med det lägsta värdet. Den returnerar dest + Nsedan . Om dest och first ange lagringsregioner dest får det inte finnas i intervallet [first, last).

move_backward

Flyttar elementen i en iterator till en annan. Flytten börjar med det sista elementet i ett angivet intervall och slutar med det första elementet i det intervallet.

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

Parameterar

first
En iterator som anger början på ett intervall att flytta element från.

last
En iterator som anger slutet på ett intervall att flytta element från. Det här elementet flyttas inte.

destEnd
En dubbelriktad iterator som hanterar positionen för en förbi det sista elementet i målintervallet.

Anmärkningar

Mallfunktionen utvärderas *(destEnd - N - 1) = move(*(last - N - 1)) en gång för var och en N i intervallet [0, last - first)för att strikt öka värdena N för att börja med det lägsta värdet. Den returnerar destEnd - (last - first)sedan . Om destEnd och first ange lagringsregioner destEnd får det inte finnas i intervallet [first, last).

move och move_backward är funktionellt likvärdiga med att använda copy och copy_backward med en flytta iterator.

next_permutation

Ordnar om elementen i ett intervall så att den ursprungliga ordningen ersätts av den lexicographically nästa större permutation om den finns. Känslan av lexicographically nästa kan anges med en binär predikat.

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

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

Parameterar

first
En dubbelriktad iterator som pekar på positionen för det första elementet i intervallet som ska permuteras.

last
En dubbelriktad iterator som pekar på positionen en förbi det sista elementet i intervallet som ska permuteras.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

true om lexicographically nästa permutation finns och har ersatt den ursprungliga ordningen av intervallet, i annat fall falseomvandlas beställningen till den lexicographically minsta permutationen.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Standardvärdet för binär predikat är mindre än och elementen i intervallet måste vara mindre än jämförbara för att säkerställa att nästa permutation är väldefinierad.

Komplexiteten är linjär med högst (last - first) / 2 växlingar.

Exempel

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

Partitionerar ett område med element som korrekt lokaliserar det n:e elementet i sekvensen i intervallet som uppfyller dessa kriterier: Alla element framför den är mindre än eller lika med det, och alla element som följer det är större än eller lika med det.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska partitioneras.

nth
En iterator med slumpmässig åtkomst som hanterar positionen för elementet som ska ordnas korrekt på partitionens gräns.

last
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i intervallet som ska partitioneras.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett jämförelsepredikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Algoritmen nth_element garanterar inte att elementen i underordningarna på någon sida av elementet nsorteras. Det ger därför färre garantier än partial_sort, som beställer elementen i intervallet under vissa valda element och kan användas som ett snabbare alternativ till partial_sort när ordningen på det lägre intervallet inte krävs.

Element är likvärdiga, men inte nödvändigtvis lika med, om inget av dem är mindre än det andra.

Medelvärdet av en sorteringskomplexitet är linjärt när det gäller last - first.

Exempel

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

Returnerar true när ett villkor aldrig finns bland element i det angivna intervallet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som anger var du ska börja kontrollera ett område med element för ett villkor.

last
En indata-iterator som anger slutet på ett område med element.

pred
Villkoret att testa för. Det här testet tillhandahålls av ett användardefinierat predikatfunktionsobjekt som definierar villkoret. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

Returnerar true om villkoret inte identifieras minst en gång i det angivna intervallet och false om villkoret identifieras.

Anmärkningar

Mallfunktionen returnerar true endast om predikatet pred(*(first + N)) för vissa N i intervallet [0, last - first)alltid falseär .

partial_sort

Ordnar ett angivet antal av de mindre elementen i ett intervall i en icke-nedlåtande ordning. Ett binärt predikat kan ange ett beställningskriterium.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska sorteras.

sortEnd
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i underordningen som ska sorteras.

last
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i intervallet som delvis ska sorteras.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Element är likvärdiga, men inte nödvändigtvis lika med, om inget av dem är mindre än det andra. Algoritmen sort är inte stabil och garanterar inte att den relativa ordningen på motsvarande element bevaras. Algoritmen stable_sort bevarar den ursprungliga ordningen.

Den genomsnittliga partiella sorteringskomplexiteten är O()last- first-loggen (sortEnd- first)).

Exempel

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

Kopierar element från ett källintervall till ett målintervall där källelementen sorteras efter antingen mindre än eller ett annat angivet binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i källintervallet.

last1
En indata iterator som hanterar positionen en förbi det sista elementet i källintervallet.

first2
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i det sorterade målintervallet.

last2
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i det sorterade målintervallet.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En iterator med slumpmässig åtkomst som adresserar elementet i målintervallet en position utöver det sista elementet som infogades från källintervallet.

Anmärkningar

Käll- och målintervallen får inte överlappa varandra och måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Det binära predikatet måste ge en strikt svag ordning så att element som inte är likvärdiga ordnas, men element som är likvärdiga inte är det. Två element är likvärdiga under mindre än, men inte nödvändigtvis lika med, om inget av dem är mindre än det andra.

Exempel

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

Klassificerar element i ett intervall i två olika uppsättningar, där dessa element uppfyller ett unary-predikat som föregår de som inte uppfyller det.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En dubbelriktad iterator som hanterar positionen för det första elementet i intervallet som ska partitioneras.

last
En dubbelriktad iterator som adresserar positionen en förbi det sista elementet i intervallet som ska partitioneras.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om ett element ska klassificeras. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

En dubbelriktad iterator som hanterar positionen för det första elementet i intervallet för att inte uppfylla predikatvillkoret.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Element a och b är likvärdiga, men inte nödvändigtvis lika, om båda pred( a, b ) är false och pred( b, a ) är false, där pred är det parameter-angivna predikatet. Algoritmen partition är inte stabil och garanterar inte att den relativa ordningen på motsvarande element bevaras. Algoritmen stable_partition bevarar den ursprungliga ordningen.

Komplexiteten är linjär: det finns (last - first) program för pred och som mest (last - first)/2 växlingar.

Exempel

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

Kopierar element för vilka ett villkor är true till ett mål och för vilket villkoret är false till ett annat. Elementen måste komma från ett angivet intervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som anger början av ett intervall för att söka efter ett villkor.

last
En indata-iterator som anger slutet på ett intervall.

dest1
En iterator för utdata som används för att kopiera element som returnerar true för ett villkor som testas med hjälp predav .

dest2
En iterator för utdata som används för att kopiera element som returnerar false för ett villkor som testas med hjälp predav .

pred
Villkoret att testa för. Testet tillhandahålls av ett användardefinierat predikatfunktionsobjekt som definierar villkoret som ska testas. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Anmärkningar

Mallfunktionen kopierar varje element X[first,last) till *dest1++ om pred(X) det är sant eller till *dest2++ om det inte är det. Den returnerar pair<OutputIterator1, OutputIterator2>(dest1, dest2).

partition_point

Returnerar det första elementet i det angivna intervallet som inte uppfyller villkoret. Elementen sorteras så att de som uppfyller villkoret kommer före de som inte gör det.

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

Parameterar

first
En ForwardIterator som anger början av ett intervall för att söka efter ett villkor.

last
En ForwardIterator som anger slutet på ett intervall.

pred
Villkoret att testa för. Testet tillhandahålls av ett användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas av elementet som söks efter. Ett unary-predikat tar ett enda argument och returnerar true eller false.

Returvärde

Returnerar ett ForwardIterator som refererar till det första elementet som inte uppfyller villkoret som testats för av pred, eller returnerar last om ett inte hittas.

Anmärkningar

Mallfunktionen hittar den första iteratorn it i [first, last) som pred(*it) är false. Sekvensen måste ordnas efter pred.

pop_heap

Tar bort det största elementet från framsidan av en heap till den näst sista positionen i intervallet och bildar sedan en ny heap från de återstående 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);

Parameterar

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i heapen.

last
En iterator med slumpmässig åtkomst som hanterar positionen en förbi det sista elementet i heapen.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

pop_heap Algoritmen är inversen av den åtgärd som utförs av push_heap-algoritmen, där ett element vid den näst sista positionen för ett intervall läggs till i en heap som består av de tidigare elementen i intervallet, om elementet som läggs till i heapen är större än något av de element som redan finns i heapen.

Heaps har två egenskaper:

• Det första elementet är alltid det största.

• Element kan läggas till eller tas bort i logaritmisk tid.

Heaps är ett idealiskt sätt att implementera prioritetsköer och de används i implementeringen av containeradaptern C++ Standard Library priority_queue Class.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Intervallet exklusive det nyligen tillagda elementet i slutet måste vara en heap.

Komplexiteten är logaritmisk och kräver som mest log (last - first) jämförelser.

Exempel

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

Ändrar ordning på elementen i ett intervall så att den ursprungliga ordningen ersätts av den lexicographically föregående större permutationen om den finns. Ett binärt predikat kan ange känslan av lexicographically föregående.

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

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

Parameterar

first
En dubbelriktad iterator som pekar på positionen för det första elementet i intervallet som ska permuteras.

last
En dubbelriktad iterator som pekar på positionen en förbi det sista elementet i intervallet som ska permuteras.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

true om den lexicographically föregående permutationen finns och har bytt ut den original- beställa av spänna; i annat fall falseomvandlas beställningen till den lexicographically största permutationen.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Standardvärdet för binär predikat är mindre än och elementen i intervallet måste vara mindre än jämförbara för att säkerställa att den tidigare permutationen är väldefinierad.

Komplexiteten är linjär, med högst (last - first)/2 växlingar.

Exempel

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

Lägger till ett element som är i slutet av ett intervall till en befintlig heap som består av de tidigare elementen i intervallet.

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

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

Parameterar

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i heapen.

last
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i intervallet som ska konverteras till en heap.

pred
Användardefinierat predikatfunktionsobjekt som definierar mening där ett element är mindre än ett annat. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

Elementet måste först skickas tillbaka till slutet av en befintlig heap och sedan används algoritmen för att lägga till det här elementet i den befintliga heapen.

Heaps har två egenskaper:

• Det första elementet är alltid det största.

• Element kan läggas till eller tas bort i logaritmisk tid.

Heaps är ett idealiskt sätt att implementera prioritetsköer och de används i implementeringen av containeradaptern C++ Standard Library priority_queue Class.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Intervallet exklusive det nyligen tillagda elementet i slutet måste vara en heap.

Komplexiteten är logaritmisk och kräver som mest log(last - first) jämförelser.

Exempel

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

Funktionen std::random_shuffle() är inaktuell och ersätts av std::shuffle. Ett kodexempel och mer information <random> finns i och Stack Overflow-inlägget Varför är std::random_shuffle metoder inaktuella i C++14?.

remove

Eliminerar ett angivet värde från ett angivet intervall utan att störa ordningen på de återstående elementen. Returnerar slutet av ett nytt intervall utan det angivna värdet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet från vilket element tas bort.

last
En vidarebefordran iterator som hanterar positionen en förbi det sista elementet i intervallet från vilket element tas bort.

value
Det värde som ska tas bort från intervallet.

Returvärde

En vidarebefordran iterator som behandlar den nya slutpositionen för det ändrade intervallet, en förbi det sista elementet i restsekvensen fri från det angivna värdet.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Ordningen på elementen som inte tas bort förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Det gör (last - first) jämförelser för likhet.

Klassenlist har en effektivare medlemsfunktionsversion av remove, som också länkar om pekare.

Exempel

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

Kopierar element från ett källintervall till ett målintervall, förutom att element i ett angivet värde inte kopieras, utan att störa ordningen på de återstående elementen. Returnerar slutet på ett nytt målintervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som hanterar positionen för det första elementet i intervallet från vilket element tas bort.

last
En indata iterator som hanterar positionen en förbi det sista elementet i intervallet från vilket element tas bort.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet som elementen tas bort till.

value
Det värde som ska tas bort från intervallet.

Returvärde

En vidarebefordran iterator som adresserar målintervallets nya slutposition, en förbi det sista elementet i kopian av restsekvensen utan det angivna värdet.

Anmärkningar

De käll- och målintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Det måste finnas tillräckligt med utrymme i målintervallet för att innehålla de restelement som ska kopieras när elementen i det angivna värdet har tagits bort.

Ordningen på elementen som inte tas bort förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Den gör (last - first) jämförelser för likhet och som mest (last - first) tilldelningar.

Exempel

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

Kopierar element från ett källintervall till ett målintervall, förutom element som uppfyller ett predikat. Element kopieras utan att störa ordningen på de återstående elementen. Returnerar slutet på ett nytt målintervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som hanterar positionen för det första elementet i intervallet från vilket element tas bort.

last
En indata iterator som hanterar positionen en förbi det sista elementet i intervallet från vilket element tas bort.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet som elementen tas bort till.

pred
Det unary predikat som måste uppfyllas är värdet för ett element som ska ersättas.

Returvärde

En vidarebefordran iterator som behandlar den nya slutpositionen för målintervallet, en förbi det sista elementet i restsekvensen fri från elementen som uppfyller predikatet.

Anmärkningar

Källintervallet som refereras måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Det måste finnas tillräckligt med utrymme i målintervallet för att innehålla de restelement som ska kopieras när elementen i det angivna värdet har tagits bort.

Ordningen på elementen som inte tas bort förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Den gör (last - first) jämförelser för likhet och som mest (last - first) tilldelningar.

Information om hur dessa funktioner fungerar finns i Kontrollerade iteratorer.

Exempel

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

Eliminerar element som uppfyller ett predikat från ett visst intervall utan att störa ordningen på de återstående elementen. Returnerar slutet av ett nytt intervall utan det angivna värdet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator som pekar på positionen för det första elementet i intervallet som elementen tas bort från.

last
En vidarebefordrande iterator som pekar på positionen en förbi det sista elementet i intervallet som elementen tas bort från.

pred
Det unary predikat som måste uppfyllas är värdet för ett element som ska ersättas.

Returvärde

En vidarebefordran iterator som behandlar den nya slutpositionen för det ändrade intervallet, en förbi det sista elementet i restsekvensen fri från det angivna värdet.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Ordningen på elementen som inte tas bort förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Det gör (last - first) jämförelser för likhet.

Listan har en effektivare medlemsfunktionsversion av remove som länkar om pekare.

Exempel

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

Undersöker varje element i ett intervall och ersätter det om det matchar ett angivet värde.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator som pekar på positionen för det första elementet i intervallet som elementen ersätts från.

last
En vidarebefordrande iterator som pekar på positionen förbi det sista elementet i intervallet som elementen ersätts från.

oldVal
Det gamla värdet för de element som ersätts.

newVal
Det nya värdet som tilldelas elementen med det gamla värdet.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Ordningen på de element som inte har ersatts förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Den gör (last - first) jämförelser för likhet och som mest (last - first) tilldelningar av nya värden.

Exempel

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

Undersöker varje element i ett källintervall och ersätter det om det matchar ett angivet värde när resultatet kopieras till ett nytt målintervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som pekar på positionen för det första elementet i intervallet från vilket element ersätts.

last
En indata iterator som pekar på positionen en förbi det sista elementet i intervallet från vilket element ersätts.

result
En utdata-iterator som pekar på det första elementet i målintervallet där den ändrade sekvensen med element kopieras.

oldVal
Det gamla värdet för de element som ersätts.

newVal
Det nya värdet som tilldelas elementen med det gamla värdet.

Returvärde

En utdata iterator som pekar på positionen en förbi det sista elementet i målintervallet den ändrade sekvensen av element kopieras till.

Anmärkningar

De käll- och målintervall som refereras får inte överlappa varandra och måste båda vara giltiga: alla pekare måste vara avrefererbara och inom sekvenserna kan den sista positionen nås från den första genom inkrementering.

Ordningen på de element som inte har ersatts förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Den gör (last - first) jämförelser för likhet och som mest (last - first) tilldelningar av nya värden.

Exempel

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

På grund av anropet random_shuffle() i föregående kod kan dina utdata vara annorlunda.

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

Undersöker varje element i ett källintervall och ersätter det om det uppfyller ett angivet predikat när resultatet kopieras till ett nytt målintervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En indata iterator som pekar på positionen för det första elementet i intervallet från vilket element ersätts.

last
En indata iterator som pekar på positionen en förbi det sista elementet i intervallet från vilket element ersätts.

result
En utdatat iterator som pekar på positionen för det första elementet i målintervallet som element kopieras till.

pred
Det unary predikat som måste uppfyllas är värdet för ett element som ska ersättas.

value
Det nya värdet som tilldelas till de element vars gamla värde uppfyller predikatet.

Returvärde

En utdata iterator som pekar på positionen en förbi det sista elementet i målintervallet den ändrade sekvensen av element kopieras till.

Anmärkningar

De käll- och målintervall som refereras får inte överlappa varandra och måste båda vara giltiga: alla pekare måste vara avrefererbara och inom sekvenserna kan den sista positionen nås från den första genom inkrementering.

Ordningen på de element som inte har ersatts förblir stabil.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Den gör (last - first) jämförelser för likhet och som mest (last - first) tilldelningar av nya värden.

Exempel

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

Undersöker varje element i ett intervall och ersätter det om det uppfyller ett angivet predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator som pekar på positionen för det första elementet i intervallet som elementen ersätts från.

last
En iterator som pekar på positionen förbi det sista elementet i intervallet som elementen ersätts från.

pred
Det unary predikat som måste uppfyllas är värdet för ett element som ska ersättas.

value
Det nya värdet som tilldelas till de element vars gamla värde uppfyller predikatet.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Ordningen på de element som inte har ersatts förblir stabil.

Algoritmen replace_if är en generalisering av algoritmen replace, vilket gör att alla predikat kan anges i stället för likhet med ett angivet konstant värde.

Den operator== som används för att fastställa likheten mellan element måste införa en likvärdighetsrelation mellan dess operander.

Komplexiteten är linjär. Den gör (last - first) jämförelser för likhet och som mest (last - first) tilldelningar av nya värden.

Exempel

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

Ändrar ordningen på elementen inom ett intervall.

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

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En dubbelriktad iterator som pekar på positionen för det första elementet i intervallet där elementen permuteras.

last
En dubbelriktad iterator som pekar på positionen en förbi det sista elementet i det intervall inom vilket elementen permuteras.

Anmärkningar

Källintervallet som refereras måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Exempel

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

Ändrar ordningen på elementen inom ett källintervall när de kopieras till ett målintervall

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En dubbelriktad iterator som pekar på positionen för det första elementet i källområdet där elementen permuteras.

last
En dubbelriktad iterator som pekar på positionen en förbi det sista elementet i källområdet där elementen permuteras.

result
En utdatat iterator som pekar på positionen för det första elementet i målintervallet som element kopieras till.

Returvärde

En utdata iterator som pekar på positionen en förbi det sista elementet i målintervallet den ändrade sekvensen av element kopieras till.

Anmärkningar

De käll- och målintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Exempel

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

Utbyter elementen i två angränsande intervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska roteras.

middle
En vidarebefordran iterator som definierar gränsen inom intervallet som adresserar positionen för det första elementet i den andra delen av intervallet vars element ska bytas ut med de i den första delen av intervallet.

last
En vidarebefordran iterator som hanterar positionen en förbi det sista elementet i intervallet som ska roteras.

Anmärkningar

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är linjär. Det gör högst (last - first) växlingar.

Exempel

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

Byter ut elementen i två närliggande intervall inom ett källintervall och kopierar resultatet till ett målintervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska roteras.

middle
En vidarebefordran iterator som definierar gränsen inom intervallet som adresserar positionen för det första elementet i den andra delen av intervallet vars element ska bytas ut med de i den första delen av intervallet.

last
En vidarebefordran iterator som hanterar positionen en förbi det sista elementet i intervallet som ska roteras.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i målintervallet.

Anmärkningar

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är linjär. Det gör högst (last - first) växlingar.

Exempel

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

Söker efter den första förekomsten av en sekvens inom ett målintervall vars element är lika med de i en viss sekvens av element eller vars element är likvärdiga i en mening som anges av ett binärt predikat för elementen i den angivna sekvensen.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last1
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas igenom.

first2
En vidarebefordran iterator som hanterar positionen för det första elementet i intervallet som ska matchas.

last2
En vidarebefordran iterator som adresserar positionen en förbi det sista elementet i intervallet som ska matchas.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

searcher
Den sökare som kapslar in det mönster som ska sökas efter och sökalgoritmen som ska användas. Mer information om sökare finns idefault_searcher klass, boyer_moore_horspool_searcher klass och boyer_moore_searcher klass.

Returvärde

En vidarebefordrande iterator som hanterar positionen för det första elementet i den första underfrågan som matchar den angivna sekvensen eller som är likvärdig i en mening som anges av ett binärt predikat.

Anmärkningar

Den operator== som används för att fastställa matchningen mellan ett element och det angivna värdet måste införa en ekvivalensrelation mellan dess operander.

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens kan den sista positionen nås från den första genom inkrementering.

Den genomsnittliga komplexiteten är linjär när det gäller storleken på det sökta intervallet. Komplexiteten i värsta fall är också linjär när det gäller storleken på sekvensen som söks efter.

Exempel

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

Söker efter den första underfrågan i ett intervall som för ett angivet antal element som har ett visst värde eller en relation till det värdet enligt ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En vidarebefordrande iterator som hanterar positionen för det första elementet i intervallet som ska sökas igenom.

last1
En vidarebefordrande iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sökas igenom.

count
Storleken på underfrågan som söks efter.

value
Värdet för elementen i sekvensen som söks efter.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En vidarebefordrande iterator som hanterar positionen för det första elementet i den första underfrågan som matchar den angivna sekvensen eller som är likvärdig i en mening som anges av ett binärt predikat.

Anmärkningar

Den operator== som används för att fastställa matchningen mellan ett element och det angivna värdet måste införa en ekvivalensrelation mellan dess operander.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är linjär när det gäller storleken på den sökta.

Exempel

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

Förenar alla element som tillhör ett sorterat källintervall, men inte till ett andra sorterat källintervall, till ett enda sorterat målintervall. Ett binärt predikat kan ange ordningskriteriet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skillnaden mellan de två källintervallen.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skillnaden mellan de två källintervallen.

first2
En indata iterator som hanterar positionen för det första elementet i andra av två sorterade källintervall i följd som ska förenas och sorteras i ett enda intervall som representerar skillnaden mellan de två källintervallen.

last2
En indata iterator som hanterar positionen ett förbi det sista elementet i andra av två på varandra följande sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skillnaden mellan de två källintervallen.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet där de två källintervallen ska förenas till ett enda sorterat intervall som representerar skillnaden mellan de två källintervallen.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Det binära predikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet och false annars.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i det sorterade målintervallet som representerar skillnaden mellan de två källintervallen.

Anmärkningar

De sorterade källintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Målintervallet bör inte överlappa något av källintervallen och bör vara tillräckligt stort för att innehålla det första källintervallet.

De sorterade källintervallen måste var och en ordnas som en förutsättning för tillämpningen av algoritmen set_difference i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen.

Åtgärden är stabil eftersom den relativa ordningen för element inom varje intervall bevaras i målintervallet. Källintervallen ändras inte av algoritmsammanfogningen.

Värdetyperna för indata-iteratorerna måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen. När det finns motsvarande element i båda källintervallen föregår elementen i det första intervallet elementen från det andra källintervallet i målintervallet. Om källintervallen innehåller dubbletter av ett element så att det finns fler i det första källintervallet än i det andra, innehåller målintervallet det tal med vilket förekomsterna av dessa element i det första källintervallet överskrider förekomsterna av dessa element i det andra källintervallet.

Komplexiteten i algoritmen är linjär med som mest 2 * ((last1 - first1) + (last2 - first2)) - 1 jämförelser för icke-snåla källintervall.

Exempel

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

Förenar alla element som tillhör båda sorterade källintervallen till ett enda, sorterat målintervall, där ordningskriteriet kan anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skärningspunkten för de två källintervallen.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skärningspunkten mellan de två källintervallen.

first2
En indata iterator som hanterar positionen för det första elementet i andra av två på varandra följande sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skärningspunkten mellan de två källintervallen.

last2
En indata iterator som hanterar positionen ett förbi det sista elementet i andra av två på varandra följande sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar skärningspunkten mellan de två källintervallen.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet där de två källintervallen ska förenas till ett enda sorterat intervall som representerar skärningspunkten mellan de två källintervallen.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Det binära predikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet och false annars.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i det sorterade målintervallet som representerar skärningspunkten mellan de två källintervallen.

Anmärkningar

De sorterade källintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Målintervallet bör inte överlappa något av källintervallen och bör vara tillräckligt stort för att innehålla målintervallet.

De sorterade källintervallen måste vara ordnade som en förutsättning för tillämpningen av sammanslagningsalgoritmen i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen.

Åtgärden är stabil eftersom den relativa ordningen för element inom varje intervall bevaras i målintervallet. Källintervallen ändras inte av algoritmen.

Värdetyperna för indata-iteratorerna måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen. När det finns motsvarande element i båda källintervallen föregår elementen i det första intervallet elementen från det andra källintervallet i målintervallet. Om källintervallen innehåller dubbletter av ett element innehåller målintervallet det maximala antalet element som förekommer i båda källintervallen.

Komplexiteten i algoritmen är linjär med som mest 2 * ((last1 - first1) + (last2 - first2)) - 1 jämförelser för icke-snåla källintervall.

Exempel

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

Förenar alla element som tillhör ett, men inte båda, av de sorterade källintervallen till ett enda, sorterat målintervall. Ett binärt predikat kan ange ordningskriteriet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar den symmetriska skillnaden mellan de två källintervallen.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar den symmetriska skillnaden mellan de två källintervallen.

first2
En indata iterator som hanterar positionen för det första elementet i andra av två på varandra följande sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar den symmetriska skillnaden mellan de två källintervallen.

last2
En indata iterator som hanterar positionen ett förbi det sista elementet i andra av två på varandra följande sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar den symmetriska skillnaden mellan de två källintervallen.

result
En utdatat iterator som hanterar positionen för det första elementet i målintervallet där de två källintervallen ska förenas till ett enda sorterat intervall som representerar den symmetriska skillnaden mellan de två källintervallen.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Det binära predikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet och false annars.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i det sorterade målintervallet som representerar den symmetriska skillnaden mellan de två källintervallen.

Anmärkningar

De sorterade källintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Målintervallet bör inte överlappa något av källintervallen och bör vara tillräckligt stort för att innehålla målintervallet.

De sorterade källintervallen måste var och en ordnas som en förutsättning för tillämpningen av algoritmen merge* i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen.

Åtgärden är stabil eftersom den relativa ordningen för element inom varje intervall bevaras i målintervallet. Källintervallen ändras inte av algoritmsammanfogningen.

Värdetyperna för indata-iteratorerna måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen. När det finns motsvarande element i båda källintervallen föregår elementen i det första intervallet elementen från det andra källintervallet i målintervallet. Om källintervallen innehåller dubbletter av ett element innehåller målintervallet det absoluta värdet för det tal med vilket förekomsterna av dessa element i ett av källintervallen överskrider förekomsterna av dessa element i det andra källintervallet.

Komplexiteten i algoritmen är linjär med som mest 2 * ((last1 - first1) + (last2 - first2)) - 1 jämförelser för icke-snåla källintervall.

Exempel

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

Förenar alla element som tillhör minst ett av två sorterade källintervall till ett enda sorterat målintervall. Ett binärt predikat kan ange ordningskriteriet.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En indata iterator som hanterar positionen för det första elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar unionen för de två källintervallen.

last1
En iterator för indata som adresserar positionen förbi det sista elementet i det första av två sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar unionen för de två källintervallen.

first2
En indata-iterator som hanterar positionen för det första elementet i andra av två sorterade källintervall i följd som ska förenas och sorteras i ett enda intervall som representerar unionen för de två källintervallen.

last2
En indata iterator som hanterar positionen ett förbi det sista elementet i andra av två på varandra följande sorterade källintervall som ska förenas och sorteras i ett enda intervall som representerar unionen av de två källintervallen.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet där de två källintervallen ska förenas till ett enda sorterat intervall som representerar unionen för de två källintervallen.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Det binära predikatet tar två argument och bör returneras true när det första elementet är mindre än det andra elementet och false annars.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i det sorterade målintervallet som representerar unionen för de två källintervallen.

Anmärkningar

De sorterade källintervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering.

Målintervallet bör inte överlappa något av källintervallen och bör vara tillräckligt stort för att innehålla målintervallet.

De sorterade källintervallen måste var och en ordnas som en förutsättning för tillämpningen av algoritmen merge i enlighet med samma ordning som ska användas av algoritmen för att sortera de kombinerade intervallen.

Åtgärden är stabil eftersom den relativa ordningen för element inom varje intervall bevaras i målintervallet. Källintervallen ändras inte av algoritmen merge.

Värdetyperna för indata-iteratorerna måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen. När det finns motsvarande element i båda källintervallen föregår elementen i det första intervallet elementen från det andra källintervallet i målintervallet. Om källintervallen innehåller dubbletter av ett element innehåller målintervallet det maximala antalet element som förekommer i båda källintervallen.

Algoritmens komplexitet är linjär med de flesta 2 * ((last1 - first1) + (last2 - first2)) - 1 jämförelser.

Exempel

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

Blandar (ordnar om) element för ett visst intervall med hjälp av en slumptalsgenerator.

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

Parameterar

first
En iterator till det första elementet i intervallet som ska blandas, inkluderande. Måste uppfylla kraven RandomAccessIterator för och ValueSwappable.

last
En iterator till det sista elementet i intervallet som ska blandas, exklusivt. Måste uppfylla kraven RandomAccessIterator för och ValueSwappable.

gen
Slumptalsgeneratorn shuffle() som funktionen ska använda för åtgärden. Måste uppfylla kraven för en UniformRandomNumberGenerator.

Anmärkningar

Mer information och ett kodexempel som använder finns shuffle()i <random>.

sort

Ordnar elementen i ett angivet intervall i en icke-nedlåtande ordning eller enligt ett ordningsvillkor som anges av ett binärt predikat.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska sorteras.

last
En iterator med slumpmässig åtkomst som adresserar positionen förbi det sista elementet i intervallet som ska sorteras.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Det här binära predikatet tar två argument och returnerar true om de två argumenten är i ordning och false på annat sätt. Den här jämförelsefunktionen måste införa en strikt svag ordning på par av element från sekvensen. Mer information finns i Algoritmer.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Element är likvärdiga, men inte nödvändigtvis lika med, om inget av dem är mindre än det andra. Algoritmen sort är inte stabil och garanterar därför inte att den relativa ordningen för motsvarande element bevaras. Algoritmen stable_sort bevarar den ursprungliga ordningen.

Medelvärdet av en sorteringskomplexitet är O( N log N ), där N = last - first.

Exempel

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

Konverterar en heap till ett sorterat intervall.

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

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

Parameterar

first
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i målhuppen.

last
En iterator med slumpmässig åtkomst som adresserar positionen en förbi det sista elementet i målhögen.

pred
Användardefinierat predikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Ett jämförelsepredikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

Heaps har två egenskaper:

• Det första elementet är alltid det största.

• Element kan läggas till eller tas bort i logaritmisk tid.

Efter programmet om den här algoritmen är det intervall som det tillämpades på inte längre en heap.

sort_heap är inte en stabil sortering eftersom den relativa ordningen för motsvarande element inte nödvändigtvis bevaras.

Heaps är ett idealiskt sätt att implementera prioritetsköer och de används i implementeringen av containeradapterklassen priority_queueC++ Standard Library.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är som mest N log N, där N = last - first.

Exempel

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

Klassificerar element i ett intervall i två olika uppsättningar, med de element som uppfyller ett unary predikat före de som inte uppfyller det, vilket bevarar den relativa ordningen för motsvarande element.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En dubbelriktad iterator som hanterar positionen för det första elementet i intervallet som ska partitioneras.

last
En dubbelriktad iterator som adresserar positionen en förbi det sista elementet i intervallet som ska partitioneras.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om ett element ska klassificeras. Ett unary-predikat tar ett enda argument och returnerar true om det är uppfyllt, eller false om det inte är uppfyllt.

Returvärde

En dubbelriktad iterator som hanterar positionen för det första elementet i intervallet för att inte uppfylla predikatvillkoret.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Element a och b är likvärdiga, men inte nödvändigtvis lika med, om båda pred( a, b ) är false och pred( b, a ) är false, där pred är det parameter-angivna predikatet. Algoritmen stable_partition är stabil och garanterar att den relativa ordningen på motsvarande element bevaras. Algoritmen partition bevarar inte nödvändigtvis den ursprungliga ordningen.

Exempel

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

Ordnar elementen i ett angivet intervall i en icke-nedlåtande ordning eller enligt ett ordningsvillkor som anges av ett binärt predikat. Den bevarar den relativa ordningen för motsvarande element.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En dubbelriktad iterator som hanterar positionen för det första elementet i intervallet som ska sorteras.

last
En dubbelriktad iterator som adresserar positionen en förbi det sista elementet i intervallet som ska sorteras.

pred
Användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Anmärkningar

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering.

Element är likvärdiga, men inte nödvändigtvis lika med, om inget av dem är mindre än det andra. Algoritmen sort är stabil och garanterar att den relativa ordningen på motsvarande element bevaras.

Körningskomplexiteten stable_sort beror på mängden tillgängligt minne, men det bästa fallet (givet tillräckligt med minne) är O(N log N) och det värsta fallet är O(N (log N)^2), där N = last - first. Vanligtvis är algoritmen sort snabbare än stable_sort.

Exempel

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

Den första åsidosättningen byter ut värdena för två objekt. Den andra åsidosättningen utbyter värdena mellan två matriser med objekt.

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

Parameterar

left
För den första åsidosättningen utbyts det första objektet som har sitt innehåll. För den andra åsidosättningen utbyts den första matrisen med objekt med dess innehåll.

right
För den första åsidosättningen utbyts det andra objektet med dess innehåll. För den andra åsidosättningen utbyts den andra matrisen med objekt.

Anmärkningar

Den första överlagringen är utformad för att fungera på enskilda objekt. Den andra överlagringen växlar innehållet i objekt mellan två matriser.

Exempel

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

Utbyter elementen i ett intervall med elementen i ett annat, lika stort intervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En vidarebefordrad iterator som pekar på den första positionen för det första intervallet vars element ska bytas ut.

last1
En vidarebefordrad iterator som pekar på en förbi den sista positionen för det första intervallet vars element ska bytas ut.

first2
En vidarebefordrande iterator som pekar på den första positionen för det andra intervallet vars element ska bytas ut.

Returvärde

En framåt iterator som pekar på en förbi den sista positionen för det andra intervallet vars element ska bytas ut.

Anmärkningar

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens kan den sista positionen nås från den första genom inkrementering. Det andra intervallet måste vara lika stort som det första intervallet.

Komplexiteten är linjär med de senaste 1 - first1-växlingarna utförda. Om element från containrar av samma typ byts swap ut bör medlemsfunktionen från containern användas, eftersom medlemsfunktionen vanligtvis har konstant komplexitet.

Exempel

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

Tillämpar ett angivet funktionsobjekt på varje element i ett källintervall eller på ett par element från två källintervall. Sedan kopieras returvärdena för funktionsobjektet till ett målintervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first1
En iterator för indata som hanterar positionen för det första elementet i det första källintervallet som ska användas.

last1
En indata-iterator som hanterar positionen en förbi det sista elementet i det första källintervallet som ska användas.

first2
En iterator för indata som hanterar positionen för det första elementet i det andra källintervallet som ska användas.

result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet.

func
Användardefinierat unary-funktionsobjekt som används i den första versionen av algoritmen för att tillämpas på varje element i det första källintervallet eller ett användardefinierat binärt funktionsobjekt (UD) som används i den andra versionen av algoritmen som tillämpas parvis, i framåtriktad ordning, på de två källintervallen.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i målintervallet som tar emot utdataelementen som transformeras av funktionsobjektet.

Anmärkningar

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom varje sekvens måste den sista positionen kunna nås från den första genom inkrementering. Målintervallet måste vara tillräckligt stort för att innehålla det transformerade källområdet.

Om resultatet anges lika med first1 i den första versionen av algoritmen blir käll- och målintervallen desamma och sekvensen ändras på plats. result Men kanske inte tilltalar en position inom intervallet [first1 + 1, last1).

Komplexiteten är linjär. Det gör som mest (last1 - first1) jämförelser.

Exempel

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

Tar bort dubblettelement som ligger bredvid varandra i ett angivet intervall.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som hanterar positionen för det första elementet i intervallet som ska genomsökas för duplicerad borttagning.

last
En vidarebefordran iterator som adresserar positionen en förbi det sista elementet i intervallet som ska genomsökas för duplicerad borttagning.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En vidarebefordrande iterator till den nya änden av den ändrade sekvensen som inte innehåller några dubbletter i följd, som adresserar positionen förbi det sista elementet som inte har tagits bort.

Anmärkningar

Båda formerna av algoritmen tar bort den andra dubbletten av ett par samma element i följd.

Algoritmens funktion är stabil så att den relativa ordningen för de odefinierade elementen inte ändras.

Det angivna intervallet måste vara giltigt. alla pekare måste vara avrefererbara och inom sekvensen kan den sista positionen nås från den första genom inkrementering. Antalet element i sekvensen ändras inte av algoritmen unique och elementen utanför slutet av den ändrade sekvensen kan avrefereras men anges inte.

Komplexiteten är linjär och kräver (last - first) - 1 jämförelser.

Listan ger en mer effektiv medlemsfunktion som är "unik", vilket kan fungera bättre.

Dessa algoritmer kan inte användas i en associativ container.

Exempel

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

Kopierar element från ett källintervall till ett målintervall förutom de duplicerade element som finns bredvid varandra.

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

Parameterar

exec
Körningsprincipen som ska användas.

first
En vidarebefordran iterator som hanterar positionen för det första elementet i källområdet som ska kopieras.

last
En vidarebefordran iterator som adresserar positionen en förbi det sista elementet i källintervallet som ska kopieras.

result
En iterator för utdata som adresserar positionen för det första elementet i målintervallet som tar emot kopian med efterföljande dubbletter borttagna.

pred
Användardefinierat predikatfunktionsobjekt som definierar villkoret som ska uppfyllas om två element ska betraktas som likvärdiga. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En utdatat iterator som adresserar positionen en förbi det sista elementet i målintervallet som tar emot kopian med efterföljande dubbletter borttagna.

Anmärkningar

Båda formerna av algoritmen tar bort den andra dubbletten av ett par samma element i följd.

Algoritmens funktion är stabil så att den relativa ordningen för de odefinierade elementen inte ändras.

De intervall som refereras måste vara giltiga. alla pekare måste vara avrefererbara och inom en sekvens kan den sista positionen nås från den första genom inkrementering.

Komplexiteten är linjär och kräver (last - first) jämförelser.

Exempel

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

Hittar positionen för det första elementet i ett ordnat intervall som har ett värde som är större än ett angivet värde. Ett binärt predikat anger ordningskriteriet.

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

Parameterar

first
Positionen för det första elementet i intervallet som ska sökas igenom.

last
Positionen en förbi det sista elementet i intervallet som ska genomsökas.

value
Värdet i det ordnade intervallet som måste överskridas av värdet för det element som iteratorn har adresserat.

pred
Användardefinierade jämförelsepredikatfunktionsobjekt som definierar i vilken mening ett element är mindre än ett annat. Ett jämförelsepredikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt.

Returvärde

En vidarebefordrande iterator till positionen för det första elementet som har ett värde som är större än ett angivet värde.

Anmärkningar

Det sorterade källintervallet som refereras måste vara giltigt. alla iteratorer måste vara avrefererbara och inom sekvensen måste den sista positionen kunna nås från den första genom inkrementering.

Ett sorterat intervall är en förutsättning för användningen av upper_bound och där ordningskriteriet är detsamma som det som anges i jämförelsepredikatet.

Intervallet ändras inte av upper_bound.

Värdetyperna för vidarebefordrade iteratorer måste vara mindre än jämförbara för att ordnas. Med tanke på två element kan du antingen fastställa att det ena är mindre än det andra eller att de är likvärdiga. (Här innebär motsvarande att ingen av dem är mindre än den andra.) Den här jämförelsen resulterar i en ordning mellan de icke-nödvändiga elementen.

Algoritmens komplexitet är logaritmisk för iteratorer med slumpmässig åtkomst och linjärt annars, med antalet steg proportionella mot (last - first).

Exempel

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