`<algorithm>` függvények

A <algorithm> fejléc a következő függvényeket biztosítja:

`adjacent_find`

Két szomszédos elemet keres, amelyek egyenlők vagy megfelelnek egy adott feltételnek.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy előremutató iterátor a keresendő tartomány első elemének pozíciójában.

last
Egy előremutató iterátor a keresendő tartomány utolsó elemén egynél korábbi pozícióban.

pred
A bináris predikátum, amely azt a feltételt adja meg, hogy teljesüljenek a keresett tartomány szomszédos elemeinek értékei.

Visszaadott érték

Az egymással egyenlő (az első verzióban) vagy a bináris predikátum által megadott feltételnek megfelelő (a második verzióban) egy másikkal egyenlő szomszédos elemek első iterátora, ha ilyen elempár található. Ellenkező esetben a függvény egy iterátort last ad vissza.

Megjegyzések

Az adjacent_find algoritmus egy nem visszahangosító szekvencia-algoritmus. A keresendő tartománynak érvényesnek kell lennie. Minden mutatónak késleltethetőnek kell lennie, az utolsó pozíciónak pedig növekményesen kell az elsőtől elérhetőnek lennie. Az algoritmus időösszetettsége lineáris a tartományban található elemek számában.

Az operator== elemek közötti egyezés meghatározásához használtnak egyenértékűségi relációt kell megállapítania az operandusok között.

példa

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

Akkor adja true vissza, ha egy feltétel az adott tartomány minden eleménél jelen van.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely jelzi, hogy hol kezdjen el ellenőrizni egy feltételt. Az iterátor jelzi, hogy hol kezdődik egy elemtartomány.

last
Egy bemeneti iterátor, amely a feltétel ellenőrzéséhez szükséges elemtartomány végét jelzi.

pred
A teszteléshez szükséges feltétel. pred egy felhasználó által definiált, nem predikátumfüggvény-objektum, amely meghatározza az ellenőrzött elem által teljesítendő feltételt. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Visszaadja true , ha a feltételt a megadott tartomány egyes elemeinél észleli, vagy ha a tartomány üres, és false egyéb esetben.

Megjegyzések

A sablonfüggvény csak akkor ad true vissza értéket, ha a tartomány [0, last - first)mindegyikéhez N a predikátum pred(*(first + N)) .true

példa

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

Akkor adja true vissza, ha egy feltétel legalább egyszer jelen van a megadott elemtartományban.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely jelzi, hogy hol kezdjen el ellenőrizni egy feltétel egy elemtartományát.

last
Egy bemeneti iterátor, amely a feltétel ellenőrzéséhez szükséges elemtartomány végét jelzi.

pred
A teszteléshez szükséges feltétel. Ezt a tesztet egy felhasználó által definiált predikátumfüggvény-objektum biztosítja. A predikátum határozza meg azt a feltételt, amelyet a tesztelt elemnek teljesítenie kell. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Visszaadja true , ha a feltételt legalább egyszer észleli a megadott tartományban, false ha a feltételt soha nem észleli.

Megjegyzések

A sablonfüggvény csak akkor ad true vissza, ha a tartomány egyes része N

[0, last - first), a predikátum pred(*(first + N)) igaz.

példa

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

Azt vizsgálja, hogy van-e olyan elem egy rendezett tartományban, amely egy megadott értékkel egyenlő, vagy egy bináris predikátum által meghatározott értelemben egyenértékű.

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

Paraméterek

first
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last
Egy előremutató iterátor, amely a keresendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

value
Az az érték, amelyet az elem értékével kell egyeztetni, vagy amelynek meg kell felelnie a feltételnek a bináris predikátum által megadott elemértékkel.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az érzéket, amelyben az egyik elem kisebb, mint a másik. A bináris predikátumok két argumentumot használnak, és true ad vissza, ha teljesülnek, és false, ha nem teljesülnek.

Visszaadott érték

trueha olyan elem található a megadott értékkel egyenlő vagy azzal egyenértékű tartományban; egyéb esetben. false

Megjegyzések

A hivatkozott rendezett forrástartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíciónak növekményesen el kell érnie az elsőtől.

A csoportosított tartományokat az algoritmus alkalmazásának binary_search előfeltételeként kell elrendezni, az algoritmus által az egyesített tartományok rendezéséhez használt sorrend szerint.

A forrástartományokat a rendszer nem módosítja binary_search.

A továbbítási iterátorok értéktípusainak kisebbnek kell lenniük, mint a rendelendőknek. Vagyis két elem alapján megállapíthatja, hogy az egyik kisebb a másiknál, vagy egyenértékű. (Itt az egyenértékű azt jelenti, hogy egyik sem kisebb, mint a másik.) Ez az összehasonlítás a nem megfelelő elemek közötti sorrendet eredményezi.

Az algoritmus összetettsége logaritmikus a véletlenszerű hozzáférésű iterátorok és a lineáris egyéb esetekben, a lépések számával arányos (last-first).

példa

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

Összehasonlít egy értéket egy felső és egy alsó határhoz, és az értékre mutató hivatkozást ad vissza, ha az a határok között van, vagy ha az érték fölött vagy alatta van, a felső vagy az alsó határra mutató hivatkozást ad vissza.

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

Paraméterek

value
Az összehasonlítandó upper érték és lower.

lower
A rögzítendő value értékek alsó határa.

upper
Az értékek felső határa, amelybe be kell szorítani value .

pred
Egy predikátum, amellyel összehasonlítható vagy lowerupper.value Az összehasonlítási predikátum két argumentumot vesz fel, és akkor ad vissza true , ha az első bizonyos értelemben kisebb, mint a második, és ellenkező esetben false.

Visszaadott érték

A ha value < lowervagy a ha gombra mutató hivatkozást upper < valuelowerupper ad vissza. Ellenkező esetben egy hivatkozást ad vissza.value

Megjegyzések

A viselkedés nem definiált, ha upper kisebb, mint lower.

`copy`

A forrástartomány elemeinek értékeit egy céltartományhoz rendeli, az elemek forrásütemezésén végighaladva új pozíciókat rendel hozzájuk előrefelé.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a forrástartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely a forrástartomány utolsó eleméhez tartozó pozíciót kezeli.

destBeg
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli.

Visszaadott érték

Egy kimeneti iterátor, amely azt a pozíciót kezeli, amely a céltartomány utolsó elemét, vagyis az iterátor címét result + (last - first) adja meg.

Megjegyzések

A forrástartománynak érvényesnek kell lennie, és elegendő helynek kell lennie a célhelyen a másolt elemek tárolásához.

Mivel az algoritmus az első elemtől kezdve sorrendben másolja a forráselemeket, a céltartomány átfedésben lehet a forrástartománysal, feltéve, hogy a last forrástartomány helye nem szerepel a céltartományban. copy az elemeket balra, jobbra azonban nem lehet áthelyezni, kivéve, ha nincs átfedés a forrás- és céltartományok között. Ha tetszőleges számú pozícióra szeretne a megfelelő helyre váltani, használja az algoritmust copy_backward .

Az copy algoritmus csak az iterátorok által mutatott értékeket módosítja, új értékeket rendel hozzá a céltartomány elemeihez. Nem használható új elemek létrehozására, és nem szúrhat be elemeket közvetlenül egy üres tárolóba.

példa

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

A forrástartomány elemeinek értékeit egy céltartományhoz rendeli, az elemek forrásütemezésén végig haladva, és visszafelé rendeli hozzájuk az új pozíciókat.

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

Paraméterek

first
Kétirányú iterátor, amely a forrástartomány első elemének pozícióját kezeli.

last
Egy kétirányú iterátor, amely a forrástartomány utolsó eleméhez tartozó pozíciót kezeli.

destEnd
Egy kétirányú iterátor, amely a céltartomány utolsó elemén egynél korábbi pozícióval foglalkozik.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemét, vagyis az iterátor címét destEnd - (last - first)adja meg.

Megjegyzések

A forrástartománynak érvényesnek kell lennie, és elegendő helynek kell lennie a célhelyen a másolt elemek tárolásához.

Az copy_backward algoritmus szigorúbb követelményeket támaszt, mint az copy algoritmus. A bemeneti és kimeneti iterátoroknak kétirányúnak kell lenniük.

Az copy_backward és move_backward az algoritmusok az egyetlen C++ standard kódtár-algoritmusok, amelyek a kimeneti tartományt a céltartomány végére mutató iterátorral jelölik ki.

Mivel az algoritmus a forráselemeket az utolsó elemtől kezdődő sorrendbe másolja, a céltartomány átfedésben lehet a forrástartománysal, feltéve, hogy a first forrástartomány helye nem szerepel a céltartományban. copy_backward Az elemeket a jobb oldalon, a bal oldalon azonban nem lehet áthelyezni, kivéve, ha nincs átfedés a forrás- és céltartományok között. Ha tetszőleges számú pozíciót szeretne balra mozgatni, használja az algoritmust copy .

Az copy_backward algoritmus csak az iterátorok által mutatott értékeket módosítja, új értékeket rendel hozzá a céltartomány elemeihez. Nem használható új elemek létrehozására, és nem szúrhat be elemeket közvetlenül egy üres tárolóba.

példa

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

Az elemek egy tartományában másolja a megadott feltételhez tartozó elemeket true .

template<class InputIterator, class OutputIterator, class UnaryPredicate>
OutputIterator copy_if(
    InputIterator first,
    InputIterator last,
    OutputIterator dest,
    UnaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class UnaryPredicate>
ForwardIterator2 copy_if(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    UnaryPredicate pred);

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a feltétel ellenőrzésére szolgáló tartomány kezdetét jelzi.

last
A tartomány végét jelző bemeneti iterátor.

dest
A másolt elemek célhelyét jelző kimeneti iterátor.

pred
Az a feltétel, amely alapján a tartomány minden eleme tesztelve van. Ezt a feltételt egy felhasználó által definiált predikátumfüggvény-objektum biztosítja. A nemáris predikátumok egy argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Egy kimeneti iterátor, amely a feltételt teljesítő minden egyes elemnél egyszer növekményesen dest növekszik. Más szóval a mínusz visszatérési érték dest egyenlő a másolt elemek számával.

Megjegyzések

A sablonfüggvény kiértékeli

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

a tartomány [0, last - first)minden egyes N értékéhezN, a legalacsonyabb értékkel kezdődő értékek szigorú növeléséhez. Ha dest és first kijelöli a tárolási régiókat, dest akkor nem szabad a tartományon [ first, last )belül lennie.

példa

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

Adott számú elem másolása.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely azt jelzi, hogy honnan másoljon elemeket.

count
Aláírt vagy aláíratlan egész számtípus, amely megadja a másolandó elemek számát.

dest
Kimeneti iterátor, amely jelzi, hogy hová kell másolni az elemeket.

Visszaadott érték

Egy kimeneti iterátort ad vissza, ahová az elemeket átmásolták. Ugyanaz, mint a paraméter visszaadott értéke dest .

Megjegyzések

A sablonfüggvény a tartományban [0, count)mindegyiknél N egyszer kiértékeli *(dest + N) = *(first + N)) az értékeket, így a legalacsonyabb értékkel kezdődő értékek N szigorúan növekednek. Ezután visszaadja a következőt dest + N: . Ha dest és first kijelöli a tárolási régiókat, dest akkor nem szabad a tartományon [first, last)belül lennie.

példa

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

Egy tartomány azon elemeinek számát adja vissza, amelyek értékei egy adott értéknek felelnek meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a bejárandó tartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely a bejárandó tartomány utolsó elemétől egy korábbi pozíciót kezeli.

value
A megszámlálandó elemek értéke.

Visszaadott érték

Az értékekkel valuerendelkező [, last) tartományfirst elemeinek számát megszámláló különbségtípusInputIterator.

Megjegyzések

Az operator== elem és a megadott érték közötti egyezés meghatározásához használtnak egyenértékűségi kapcsolatot kell megállapítania az operandusok között.

Ez az algoritmus általánosított, hogy megszámolja azokat az elemeket, amelyek megfelelnek a sablonfüggvény count_ifbármely predikátumának.

példa

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

Egy tartomány azon elemeinek számát adja vissza, amelyek értékei megfelelnek egy adott feltételnek.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely a keresendő tartomány utolsó elemétől egy korábbi pozíciót kezeli.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt a feltételt, amelyet teljesíteni kell, ha egy elemet meg kell számolni. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

A predikátum által meghatározott feltételnek megfelelő elemek száma.

Megjegyzések

Ez a sablonfüggvény az algoritmus countáltalánosítása, amely az "egy adott értéket egyenlő" predikátumot lecseréli bármely predikátumra.

példa

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

A bináris predikátum által meghatározott értelemben vett egyenlőség vagy egyenértékűség két tartományelemét hasonlítja össze elem szerint.

Különböző std::equal tárolótípusok elemeinek (például vector és list) összehasonlítása, illetve különböző elemtípusok összehasonlításakor, vagy ha a tárolók alrangjainak összehasonlítására van szükség. Ellenkező esetben, ha azonos típusú elemeket hasonlít össze ugyanabban a tárolótípusban, használja az egyes tárolókhoz megadott nem tag operator== elemeket.

A C++14 kódban használja a kéttartományos túlterheléseket, mert azok a túlterhelések, amelyek csak a második tartomány egyetlen iterátorát használják, nem észlelnek különbségeket, ha a második tartomány hosszabb az első tartománynál. Ezek a túlterhelések nem definiált viselkedést eredményeznek, ha a második tartomány rövidebb, mint az első tartomány.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első tesztelendő tartomány első elemének pozícióját kezeli.

last1
Egy bemeneti iterátor, amely az első tesztelendő tartomány utolsó elemét megelőző pozíciót kezeli.

first2
Egy bemeneti iterátor, amely a tesztelendő második tartomány első elemének pozícióját kezeli.

last2
Egy bemeneti iterátor, amely a tesztelendő második tartomány utolsó elemén egynél korábbi pozícióval foglalkozik.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza, hogy a feltétel teljesüljön, ha két elemet egyenértékűnek kell tekinteni. A bináris predikátumok két argumentumot használnak, és true ad vissza, ha teljesülnek, és false, ha nem teljesülnek.

Visszaadott érték

trueha és csak akkor, ha a tartományok azonosak vagy egyenértékűek a bináris predikátum alatt elem szerint összehasonlítva; egyéb esetben. false

Megjegyzések

A keresendő tartománynak érvényesnek kell lennie; az összes iterátornak el kell hareferensnek lennie, és az utolsó pozíció az elsőtől a növekményesen érhető el.

Ha a két tartomány egyenlő hosszúságú, akkor az algoritmus időösszetettsége lineáris a tartományban található elemek számában. Ellenkező esetben a függvény azonnal visszaadja a függvényt false.

Nincs szükség sem operator== a felhasználó által definiált predikátumra, sem az operandusok közötti szimmetrikus, reflexív és tranzitív ekvivalencia-kapcsolat bevezetéséhez.

példa

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

Rendezett tartomány esetén megkeresi azt az alrangot, amelyben az összes elem egy adott értékkel egyenértékű.

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

Paraméterek

first
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last
Egy előremutató iterátor, amely a keresendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

value
A keresett érték a rendezett tartományban.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az érzést, amelyben az egyik elem kisebb, mint a másik. Az összehasonlítási predikátum két argumentumot vesz fel, és akkor ad vissza true , ha elégedett, és false ha nem teljesül.

Visszaadott érték

Egy olyan továbbítási iterátorpár, amely egy altartományt határoz meg a keresett tartományban, amelyben az összes elem megegyezik value a használt bináris predikátum által meghatározott értelemben (vagy pred az alapértelmezettnél kisebb).

Ha a tartomány egyik eleme sem felel meg ennek value, akkor a visszaadott párban lévő forward iterátorok egyenlők, és megadják azt a pontot, ahová value a tartomány sorrendjének megzavarása nélkül beszúrhatók.

Megjegyzések

Az algoritmus lower_boundáltal visszaadott pár első iterátora a második iterátor upper_bound.

A tartományt a megadott predikátumnak equal_rangemegfelelően kell rendezni. Ha például a nagyobb predikátumot szeretné használni, a tartományt csökkenő sorrendbe kell rendezni.

A visszaadott equal_range iterátorok párja által meghatározott lehetséges üres altartomány elemei egyenértékűek lesznek a használt predikátum által meghatározott értelemben vett értékkel .

Az algoritmus összetettsége logaritmikus a véletlenszerű hozzáférésű iterátorok és a lineáris egyéb esetekben, a lépések számával arányos (last - first).

példa

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

Ugyanazt az új értéket rendeli hozzá egy adott tartomány minden eleméhez.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy továbbító iterátor, amely a bejárandó tartomány első elemének pozícióját kezeli.

last
Egy előremutató iterátor, amely a bejárandó tartomány utolsó elemétől egy korábbi pozíciót kezeli.

value
A tartomány elemeihez hozzárendelendő érték [first, last).

Megjegyzések

A céltartománynak érvényesnek kell lennie; az összes mutatónak el kell hareferensnek lennie, és az utolsó pozíció az elsőtől kezdve növekményesen érhető el. Az összetettség lineáris a tartomány méretével.

példa

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

Új értéket rendel hozzá egy adott elemtől kezdődő tartomány adott számú eleméhez.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy kimeneti iterátor, amely az értékhez valuehozzárendelni kívánt tartomány első elemének pozícióját kezeli.

count
Aláírt vagy aláíratlan egész számtípus, amely megadja az értékhez rendelendő elemek számát.

value
A tartomány elemeihez hozzárendelendő érték [first, first + count).

Visszaadott érték

Az utolsó, ha count> nullával kitöltött elemet követő elem iterátora, ellenkező esetben az első elem.

Megjegyzések

példa

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

Megkeresi egy elem első előfordulásának helyét egy megadott értékkel rendelkező tartományban.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a megadott értékre keresendő tartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely a megadott érték kereséséhez használt tartomány utolsó elemétől egy korábbi pozíciót kezeli.

value
A keresendő érték.

Visszaadott érték

Egy bemeneti iterátor, amely a megadott érték első előfordulását kezeli a keresett tartományban. Ha nem található azonos értékkel rendelkező elem, akkor a függvény a függvényt lastadja vissza.

Megjegyzések

Az operator== elem és a megadott érték közötti egyezés meghatározásához használtnak egyenértékűségi kapcsolatot kell megállapítania az operandusok között.

Ha egy példakódra van példa, find()tekintse meg a következőt find_if:

`find_end`

A megadott sorozattal azonos vagy bináris predikátum által meghatározott értelemben egyenértékű utolsó részhalmaz tartományát keresi meg.

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

Paraméterek

first1
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last1
Egy olyan továbbítási iterátor, amely a keresendő tartomány utolsó elemét megelőző pozíciót kezeli.

first2
A keresési tartomány első elemének pozícióját megadó forward iterator.

last2
Egy előremutató iterátor, amely a keresett tartomány utolsó eleméhez tartozó pozíciót kezeli.

Visszaadott érték

A megadott sorrendnek megfelelő [első1, utolsó1] részhalmaz első elemének pozícióját megadó forward iterátor.

Megjegyzések

Az operator== elem és a megadott érték közötti egyezés meghatározásához használtnak egyenértékűségi kapcsolatot kell megállapítania az operandusok között.

A hivatkozott tartományoknak érvényesnek kell lenniük; minden mutatónak el kell hareferensnek lennie, és az egyes sorozatokon belül az utolsó pozíció az elsőtől a növekményesen érhető el.

példa

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

A céltartományon belüli értékek közül bármelyik első előfordulását keresi. Vagy megkeresi a bináris predikátum által meghatározott értelemben egyenértékű több elem első előfordulását az elemek egy meghatározott halmazával.

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

Paraméterek

first1
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last1
Egy előremutató iterátor, amely a keresendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

first2
Egy forward iterator, amely a egyeztetendő tartomány első elemének pozícióját kezeli.

last2
Egy előremutató iterátor, amely a megfeleltetendő tartomány utolsó elemén egynél korábbi pozícióval foglalkozik.

Visszaadott érték

A megadott sorrendnek megfelelő vagy a bináris predikátum által meghatározott értelemben egyenértékű első részhalmaz első elemének pozícióját megadó forward iterátor.

Megjegyzések

Az operator== elem és a megadott érték közötti egyezés meghatározásához használtnak egyenértékűségi kapcsolatot kell megállapítania az operandusok között.

példa

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

Megkeresi egy elem első előfordulásának helyét egy megadott feltételnek megfelelő tartományban.

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

Paraméterek

first
Egy bemeneti iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely a keresendő tartomány utolsó elemétől egy korábbi pozíciót kezeli.

pred
Felhasználó által definiált predikátumfüggvény-objektum vagy lambdakifejezés , amely meghatározza a keresett elem által teljesítendő feltételt. A nem jegyző predikátumok egyetlen argumentumot használnak, és akkor ad vissza true , ha teljesülnek, vagy false ha nem teljesülnek. Az aláírásnak pred ténylegesen meg kell lennie bool pred(const T& arg);, ahol T egy típus, amely InputIterator implicit módon konvertálható hareferensként. A const kulcsszó csak annak szemléltetésére jelenik meg, hogy a függvényobjektum vagy a lambda nem módosíthatja az argumentumot.

Visszaadott érték

Bemeneti iterátor, amely a tartomány első olyan elemére hivatkozik, amely megfelel a predikátum által megadott feltételnek (a predikátum eredménye true). Ha nem található olyan elem, amely megfelel a predikátumnak, akkor a függvény a következőt adja lastvissza: .

Megjegyzések

Ez a sablonfüggvény az algoritmus findáltalánosítása, amely az "egy adott értéket egyenlő" predikátumot lecseréli bármely predikátumra. A logikai ellentét (keresse meg az első elemet, amely nem felel meg a predikátumnak), lásd find_if_not: .

példa

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

A megadott tartomány első olyan elemét adja vissza, amely nem felel meg egy feltételnek.

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

Paraméterek

first
Egy bemeneti iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely a keresendő tartomány utolsó elemétől egy korábbi pozíciót kezeli.

pred
Felhasználó által definiált predikátumfüggvény-objektum vagy lambda kifejezés , amely meghatározza azt a feltételt, hogy a keresett elem ne feleljen meg. A nem jegyző predikátumok egyetlen argumentumot használnak, és akkor ad vissza true , ha teljesülnek, vagy false ha nem teljesülnek. Az aláírásnak pred ténylegesen meg kell lennie bool pred(const T& arg);, ahol T egy típus, amely InputIterator implicit módon konvertálható hareferensként. A const kulcsszó csak annak szemléltetésére jelenik meg, hogy a függvényobjektum vagy a lambda nem módosíthatja az argumentumot.

Visszaadott érték

Bemeneti iterátor, amely a tartomány első olyan elemére hivatkozik, amely nem felel meg a predikátum által megadott feltételnek (a predikátum eredménye false). Ha az összes elem megfelel a predikátumnak (a predikátum minden elemnél eredményt ad true ), akkor lasta függvény eredménye .

Megjegyzések

A kódhoz könnyen adaptálható find_if_not()példakódért tekintse meg a következőt find_if:

`for_each`

Egy megadott függvényobjektumot alkalmaz egy tartományon belüli továbbítási sorrend minden elemére, és visszaadja a függvényobjektumot.

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

Paraméterek

first
Egy bemeneti iterátor, amely a tartomány első elemének pozícióját kezeli.

last
Egy bemeneti iterátor, amely azt a pozíciót kezeli, amely a tartomány utolsó eleme mellett található.

func
A tartomány egyes elemeire alkalmazott, felhasználó által definiált függvényobjektum.

Visszaadott érték

A függvényobjektum egy példánya, miután alkalmazták a tartomány összes elemére.

Megjegyzések

Az algoritmus for_each rugalmas, lehetővé téve az egyes elemek módosítását egy tartományon belül, különböző, felhasználó által megadott módokon. A templatizált függvények más paraméterek átadásával újra felhasználhatók módosított formában. A felhasználó által definiált függvények olyan belső állapotban halmozhatják fel az információkat, amelyeket az algoritmus a tartomány összes elemének feldolgozása után visszaadhat.

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíciónak növekményesen el kell érnie az elsőtől.

Az összetettség lineáris, legfeljebb (last - first) összehasonlítással.

példa

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

Megadott függvényobjektumot alkalmaz egy adott elemtől kezdődő tartomány adott számú elemére.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Bemeneti iterátor a tartomány első elemének pozíciójában.

count
A működtetni kívánt elemek száma.

func
Felhasználó által definiált függvényobjektum, amely a tartomány minden elemére alkalmazható [first, first + count).

Visszaadott érték

Az elem iterátora, amely az utolsó feldolgozott elemet követi, ha count> nulla, ellenkező esetben az első elem.

Megjegyzések

count nem negatívnak kell lennie, és a tartománynak legalább count a következőtől firstkezdődő elemeinek kell lenniük.

példa

Ez a példa egy függvényobjektum-osztályt határoz meg. Az éles kód gyakran használ hasonló lambda eredményt kevesebb kóddal.

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

Hozzárendeli a függvényobjektum által létrehozott értékeket egy tartomány minden eleméhez.

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

Paraméterek

first
Egy előremutató iterátor a tartomány első elemének pozíciójában, amelyhez az értékeket hozzá kell rendelni.

last
Egy előremutató iterátor azon a pozíción, amely a tartomány utolsó eleme mellett található, amelyhez az értékeket hozzá kell rendelni.

gen
Olyan függvényobjektum, amely argumentumok nélkül van meghívva a tartomány egyes elemeihez hozzárendelendő értékek létrehozásához.

Megjegyzések

A függvényobjektumot a tartomány minden egyes eleméhez meghívja a függvény, és nem kell ugyanazt az értéket visszaadnia minden alkalommal, amikor meghívják. Előfordulhat például, hogy egy fájlból olvas, vagy egy helyi állapotra hivatkozik és módosítja azt. A generátor eredménytípusának átalakíthatónak kell lennie a tartomány előremutató iterátorának értéktípusára.

A hivatkozott tartománynak érvényesnek kell lennie. Minden mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíciónak növekményesen kell az elsőtől elérhetőnek lennie.

Az összetettség lineáris, pontosan last - first a generátorhoz intézett hívásokkal.

példa

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

Hozzárendeli a függvényobjektum által létrehozott értékeket egy tartomány megadott számú eleméhez. Az utolsó hozzárendelt értéken túli pozíciót adja vissza.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy kimeneti iterátor, amely a tartomány első elemének pozícióját kezeli, amelyhez az értékeket hozzá kell rendelni.

count
Aláírt vagy aláíratlan egész számtípus, amely meghatározza, hogy a generátorfüggvény hány elemet rendel hozzá az értékhez.

gen
Olyan függvényobjektum, amelyet argumentumok nélkül hívunk meg, és amelyek a tartomány egyes elemeihez hozzárendelendő értékek létrehozásához használhatók.

Megjegyzések

Az összetettség lineáris, és pontosan count a generátorhoz intézett hívásokra van szükség.

példa

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

Annak vizsgálata, hogy egy rendezett tartomány tartalmazza-e a második rendezett tartomány összes elemét, ahol az elemek közötti rendezési vagy egyenértékűségi feltételt bináris predikátum határozza meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első elem pozícióját kezeli az első két rendezési forrástartományban, amelyet tesztelni kell annak ellenőrzéséhez, hogy a második elem minden eleme szerepel-e az elsőben.

last1
Egy bemeneti iterátor, amely az első két rendezési forrástartomány utolsó elemén egynél korábbi pozíciót kezel, és tesztelni szeretné, hogy a második elem minden eleme szerepel-e az elsőben.

first2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második részének első elemének pozícióját kezeli, és azt vizsgálja, hogy a második elem összes eleme szerepel-e az elsőben.

last2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második részének utolsó elemén egynél korábbi pozíciót kezeli annak ellenőrzéséhez, hogy a második összes eleme szerepel-e az elsőben.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az érzéket, amelyben az egyik elem kisebb, mint a másik. Az összehasonlítási predikátum két argumentumot vesz fel, és akkor ad vissza true , ha elégedett, és false ha nem teljesül.

Visszaadott érték

trueha az első rendezett tartomány tartalmazza a második rendezési tartomány összes elemét; egyéb esetben. false

Megjegyzések

A teszt másik módja, hogy meghatározta, hogy a második forrástartomány az első forrástartomány részhalmaza-e.

A hivatkozott rendezett forrástartományoknak érvényesnek kell lenniük; minden mutatónak késleltethetőnek kell lennie, és az egyes sorozatokon belül az utolsó pozíciónak növekményesen kell az elsőtől elérhetőnek lennie.

Az algoritmus includesalkalmazásának előfeltételeként a rendezett forrástartományokat az algoritmus által az egyesített tartományok rendezéséhez használt rendezéssel kell rendezni.

A forrástartományokat az algoritmus mergenem módosítja.

Az algoritmus összetettsége lineáris, legfeljebb 2 * ((last1 - first1) + (last2 - first2)) - 1 egyetlen forrástartomány összehasonlításával.

példa

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

Két egymást követő rendezett tartomány elemeit egyetlen rendezett tartományba egyesíti, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Kétirányú iterátor, amely a két egymást követő rendezési tartomány első elemének pozícióját kezeli, és egyetlen tartományba rendezi.

middle
Kétirányú iterátor, amely a két egymást követő rendezési tartomány második részének első elemének pozícióját kezeli, és egyetlen tartományba rendezi.

last
Kétirányú iterátor, amely a két egymást követő rendezési tartomány második elemén egynél korábbi pozíciót kezeli, és egyetlen tartományba rendezi.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az érzést, amelyben az egyik elem kisebb, mint a másik. Az összehasonlító predikátum két argumentumot vesz fel, és akkor kell visszaadnia true , ha az első elem kisebb, mint a második elem, és false ellenkező esetben.

Megjegyzések

A hivatkozott sorba rendezett egymást követő tartományoknak érvényesnek kell lenniük; minden mutatónak késleltethetőnek kell lennie, és az egyes sorozatokon belül az utolsó pozíciónak növekményesen kell az elsőtől elérhetőnek lennie.

A sorba rendezett egymást követő tartományokat az algoritmus alkalmazásának inplace_merge előfeltételeként kell elrendezni az algoritmus által az egyesített tartományok rendezéséhez használt sorrend szerint. A művelet stabil, mivel az egyes tartományok elemeinek relatív sorrendje megmarad. Ha mindkét forrástartományban azonos elemek találhatók, az elem az első tartomány, amely megelőzi az elemet a kombinált tartomány második elemétől.

Az összetettség a rendelkezésre álló memóriától függ, mivel az algoritmus ideiglenes pufferbe foglalja a memóriát. Ha elegendő memória áll rendelkezésre, a legjobb eset lineáris az (last - first) - 1 összehasonlításokkal; ha nincs rendelkezésre álló kiegészítő memória, akkor a legrosszabb eset az N log(N), ahol - Nlast = first.

példa

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

Visszaadja true , ha a megadott tartomány elemei halommemóröket alkotnak.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Véletlenszerű hozzáférési iterátor, amely egy halom keresésére szolgáló tartomány kezdetét jelzi.

last
Egy véletlenszerű hozzáférési iterátor, amely egy tartomány végét jelzi.

pred
Az elemek sorrendjének tesztelésére használt feltétel. Az összehasonlítási predikátum két argumentumot vesz fel, és visszaadja true vagy false.

Visszaadott érték

Visszaadja true , ha a megadott tartomány elemei halomként jelennek meg, false ha nem.

Megjegyzések

Az első sablonfüggvény ad is_heap_until(first , last) == lastvissza.

A második sablonfüggvény visszaadja

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

is_heap_until

Egy olyan iterátort ad vissza, amely a tartomány első eleménél [ first, ) van elhelyezve, lastamely nem felel meg a halomrendezési feltételnek, vagy end ha a tartomány halom alakú.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy véletlenszerű hozzáférési iterátor, amely meghatározza egy tartomány első elemét, hogy ellenőrizze a halomot.

last
Egy véletlenszerű hozzáférési iterátor, amely megadja a tartomány végét, hogy ellenőrizze a halomot.

pred
Bináris predikátum, amely meghatározza a halomra vonatkozó szigorú gyenge rendezési feltételt. Az alapértelmezett predikátum az, std::less<> amikor pred nincs megadva.

Visszaadott érték

Visszaadja last , ha a megadott tartomány halom, vagy egy vagy kevesebb elemet tartalmaz. Ellenkező esetben visszaad egy iterátort a talált első elemhez, amely nem felel meg a halomfeltételnek.

Megjegyzések

Az első sablonfüggvény az utolsó iterátort next[first, last) adja vissza, ahol [first, next) a függvényobjektum std::less<>által rendezett halom van. Ha a távolság last - first kisebb, mint 2, a függvény ad vissza last.

A második sablonfüggvény ugyanúgy viselkedik, mint az első, azzal a kivétellel, hogy a predikátumot pred használja a halomrendezési feltétel helyett std::less<> .

is_partitioned

Visszaadja true , ha az adott tartomány azon elemei, amelyek egy feltételt tesztelnek true , a tesztelt falseelemek elé kerülnek.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Bemeneti iterátor, amely jelzi, hogy egy tartomány hol kezdi ellenőrizni a feltételt.

last
Egy tartomány végét jelző bemeneti iterátor.

pred
A teszteléshez szükséges feltétel. Ezt a tesztet egy felhasználó által definiált predikátumfüggvény-objektum biztosítja, amely meghatározza azt a feltételt, amelyet a keresett elemnek teljesítenie kell. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Akkor adja true vissza, ha az adott tartomány azon elemei, amelyek egy feltételt tesztelnek true , a tesztelt falseelemek elé kerülnek , máskülönben pedig visszakerülnek false.

Megjegyzések

A sablonfüggvény csak akkor ad vissza eredményttrue, ha a benne lévő [first, last) összes elem particionálva predvan; vagyis az összes olyan elemnél X[first, last), amelyben az igaz, az összes olyan elem előtt fordul elő, amelynek pred (X)pred (Y) az értéke .falseY

`is_permutation`

Visszaadja true , ha mindkét tartomány ugyanazokat az elemeket tartalmazza, függetlenül attól, hogy az elemek ugyanabban a sorrendben vannak-e. A C++14 kódban használja a kéttartományos túlterheléseket, mert azok a túlterhelések, amelyek csak a második tartomány egyetlen iterátorát használják, nem észlelnek különbségeket, ha a második tartomány hosszabb az első tartománynál. Ezek a túlterhelések nem definiált viselkedést eredményeznek, ha a második tartomány rövidebb, mint az első tartomány.

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

Paraméterek

first1
A tartomány első elemére hivatkozó továbbítási iterátor.

last1
Egy előremutató iterátor, amely a tartomány utolsó elemén múlt egyet hivatkozik.

first2
Az összehasonlításhoz használt második tartomány első elemére hivatkozó forward iterátor.

last2
Egy előremutató iterátor, amely egy második tartomány utolsó elemén múlt egy, összehasonlításhoz használt elemet jelöl.

pred
Egy olyan predikátum, amely az egyenértékűséget teszteli, és visszaad egy bool.

Visszaadott érték

trueha a tartományok átrendezhetők úgy, hogy az összehasonlító predikátumnak megfelelően azonosak legyenek; egyéb esetben. false

Megjegyzések

is_permutation a legrosszabb esetben kvadratikus összetettséggel rendelkezik.

Az első sablonfüggvény feltételezi, hogy a tartománynak annyi eleme van, first2 mint amennyi a megadott tartományban [first1, last1)van. Ha a második tartományban több elem is szerepel, a rendszer figyelmen kívül hagyja őket; ha kevesebb, nem definiált viselkedés fog bekövetkezni. A harmadik sablonfüggvény (C++14 és újabb) nem teszi ezt a feltételezést. Mindkettő csak akkor ad [first1, last1) visszatrue, ha a tartomány minden eleméhez X ugyanannyi elem Y tartozik ugyanabban a tartományban, amelynek X == Y a kezdő vagy [first2, last2)a .first2 operator== Itt párosított összehasonlítást kell végeznie az operandusok között.

A második és negyedik sablonfüggvények ugyanúgy viselkednek, kivéve, hogy azokat a következőre Pred(X, Y)cserélikoperator==(X, Y): . A helyes viselkedéshez a predikátumnak szimmetrikusnak, reflexívnek és tranzitívnak kell lennie.

példa

Az alábbi példa a is_permutationhasználatát mutatja be:

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

Akkor adja true vissza, ha a megadott tartomány elemei rendezett sorrendben vannak.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy továbbítási iterátor, amely jelzi, hogy hol kezdődik az ellenőrizendő tartomány.

last
Egy tartomány végét jelző továbbítási iterátor.

pred
A két elem közötti sorrend meghatározásának feltétele. Az összehasonlítási predikátum két argumentumot vesz fel, és visszaadja true vagy false. Ez a predikátum ugyanazt a feladatot hajtja végre, mint a operator<.

Megjegyzések

Az első sablonfüggvény ad is_sorted_until( first, last ) == lastvissza. A operator< függvény végrehajtja a sorrend összehasonlítását.

A második sablonfüggvény ad is_sorted_until( first, last , pred ) == lastvissza. A pred predikátumfüggvény végrehajtja a sorrend összehasonlítását.

`is_sorted_until`

ForwardIterator Egy adott tartományból rendezett sorrendben lévő utolsó elemre beállított értéket ad vissza.

A második verzió lehetővé teszi egy összehasonlító függvényobjektum megadását, amely akkor ad vissza, true ha két adott elem rendezési sorrendben van, és false egyébként.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy továbbítási iterátor, amely jelzi, hogy hol kezdődik az ellenőrizendő tartomány.

last
Egy tartomány végét jelző továbbítási iterátor.

pred
A két elem közötti sorrend meghatározásának feltétele. Az összehasonlítási predikátum két argumentumot vesz fel, és visszaadja true vagy false.

Visszaadott érték

Egy halmazt ForwardIterator a rendezési sorrend utolsó elemének ad vissza. A rendezési sorrend a következőből firstindul: .

Megjegyzések

Az első sablonfüggvény az utolsó iterátort next[first, last] adja vissza, amely [first, next) egy rendezési sorrend szerint operator<van rendezve. Ha distance() 2-nél kisebb, a függvény visszaadja a függvényt last.

A második sablonfüggvény ugyanúgy viselkedik, azzal a kivétellel, hogy lecseréli a következőre operator<(X, Y)pred(X, Y): .

`iter_swap`

Két, megadott iterátorpár által hivatkozott értéket cserél le.

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

Paraméterek

left
Az egyik olyan továbbítási iterátor, amelynek értékét cserélni kell.

right
Azoknak a forward iterátoroknak a második része, amelyek értékét cserélni kell.

Megjegyzések

swap a iter_swap előnyben kell részesíteni, amelyet a C++ Standard tartalmazott a visszamenőleges kompatibilitás érdekében. Ha Fit1 és Fit2 továbbítási iterátor, akkor iter_swap( Fit1, Fit2 )az egyenértékű a következővel swap( *Fit1, *Fit2 ): .

A bemeneti továbbító iterátorok értéktípusainak ugyanazzal az értékkel kell rendelkezniük.

példa

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

Elemet hasonlít össze elem szerint két sorozat között annak meghatározásához, hogy melyik kisebb a kettő közül.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első összehasonlítandó tartomány első elemének pozícióját kezeli.

last1
Egy bemeneti iterátor, amely az első összehasonlítandó tartomány utolsó elemét követő pozíciót kezeli.

first2
Egy bemeneti iterátor, amely az összehasonlítandó második tartomány első elemének pozícióját kezeli.

last2
Egy bemeneti iterátor, amely az összehasonlítandó második tartomány utolsó elemétől egy korábbi pozíciót kezeli.

Visszaadott érték

true ha az első tartomány lexikálisan kisebb, mint a második tartomány; egyéb esetben false.

Megjegyzések

A sorozatok lexikográfiai összehasonlítása elem szerint hasonlítja össze őket, amíg:

Két megfelelő elemet egyenlőtlennek talál, és az összehasonlítás eredménye a sorozatok összehasonlítása.
Nem találhatók egyenlőtlenségek, de az egyik sorozat több elemből áll, mint a másik, és a rövidebb sorozat kisebb, mint a hosszabb sorozat.
Nem találhatók egyenlőtlenségek, és a sorozatok ugyanannyi elemből állnak, így a sorozatok egyenlőek, és az összehasonlítás eredménye .false

példa

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

Megkeresi egy rendezett tartomány első elemének pozícióját, amely egy megadott értéknél nagyobb vagy azzal egyenértékű értékkel rendelkezik. A rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

first
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last
Egy előremutató iterátor, amely a keresendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

value
Az az érték, amelynek első pozícióját vagy lehetséges első pozícióját keresi a rendezett tartományban.

Visszaadott érték

Egy előremutató iterátor egy rendezett tartomány első elemének helyén egy megadott értéknél nagyobb vagy azzal egyenértékű értékkel. Az egyenértékűség bináris predikátummal is megadható.

Megjegyzések

A hivatkozott rendezett forrástartománynak érvényesnek kell lennie; minden iterátornak el kell hareferensnek lennie, és a sorrenden belül az utolsó pozíciónak az elsőtől növekményesen kell elérhetőnek lennie.

A rendezett tartomány a használat lower_bound előfeltétele, és ahol a rendezés megegyezik a bináris predikátummal megadottakkal.

A tartományt az algoritmus lower_boundnem módosítja.

Az algoritmus összetettsége logaritmikus a véletlenszerű hozzáférésű iterátorok és a lineáris egyéb esetekben, a lépések számával arányos (last - first).

példa

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

Egy megadott tartomány elemeit egy halomra alakítja át, amelyben az első elem a legnagyobb, és amelynek rendezési feltételét bináris predikátummal lehet megadni.

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

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

Paraméterek

first
Egy véletlenszerű hozzáférésű iterátor, amely a tartomány első elemének pozícióját kezeli, amelyet halomsá alakít át.

last
Egy véletlenszerű hozzáférésű iterátor, amely egy olyan pozíciót kezel, amely a tartomány utolsó elemét egy halommá alakítja.

Megjegyzések

A halmok két tulajdonsággal rendelkeznek:

Az első elem mindig a legnagyobb.
Az elemek logaritmikus időben hozzáadhatók vagy eltávolíthatók.

A halmok ideális megoldást jelentenek a prioritási üzenetsorok implementálásához, és a C++ standard kódtár tárolóadapetorának priority_queue osztály implementálásához használják őket.

Az összetettség lineáris, összehasonlítást igényel 3 * (last - first) .

példa

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

Két objektumot hasonlít össze, és a kettő közül a nagyobbat adja vissza, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

left
Az összehasonlítandó két objektum közül az első.

right
A két összehasonlítandó objektum közül a második.

pred
A két objektum összehasonlítása bináris predikátum.

inlist
Az összehasonlítandó objektumokat tartalmazó inicializálólista.

Visszaadott érték

A két objektum közül a nagyobb, hacsak egyik sem nagyobb; ebben az esetben a két objektum közül az elsőt adja vissza. Ha meg van adva, initializer_list a listában szereplő objektumok közül a legnagyobbat adja vissza.

Megjegyzések

Az max algoritmus szokatlan abban, hogy az objektumok paraméterekként vannak átadva. A legtöbb C++ standard kódtár-algoritmus számos olyan elemen működik, amelyek pozícióját paraméterekként átadott iterátorok határozzák meg. Ha olyan függvényre van szüksége, amely több elemen működik, használja max_element inkább. A Visual Studio 2017 lehetővé teszi constexpr azokat a túlterheléseket, amelyek egy initializer_list.

példa

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

Megkeresi a legnagyobb elem első előfordulását egy adott tartományban, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
A legnagyobb elem kereséséhez használt tartomány első elemének pozícióját megadó továbbítási iterátor.

last
Egy előremutató iterátor, amely a legnagyobb elem kereséséhez használt tartomány utolsó eleme mellett lévő pozíciót kezeli.

Visszaadott érték

Egy előremutató iterátor, amely a keresett tartomány legnagyobb elemének első előfordulásának pozícióját kezeli.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és minden sorozaton belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az összetettség lineáris: (last - first) - 1 összehasonlításra van szükség egy nem megfelelő tartományhoz.

példa

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

Két rendezett forrástartomány összes elemét egyetlen, rendezett céltartományba egyesíti, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első két rendezendő forrástartomány első elemének pozícióját kezeli, és egyetlen tartományba rendezi.

last1
Egy bemeneti iterátor, amely az első két rendezendő forrástartomány utolsó elemén egynél korábbi pozíciót kezel, és egyetlen tartományba rendezi.

first2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második részének első elemének pozícióját kezeli, és egyetlen tartományba rendezi.

last2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második utolsó elemén egynél korábbi pozíciót kezeli, és egyetlen tartományba rendezi.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli, ahol a két forrástartományt egyetlen rendezett tartományba kell egyesíteni.

Visszaadott érték

Egy kimeneti iterátor, amely a rendezett céltartomány utolsó elemét megelőző pozíciót kezeli.

Megjegyzések

A hivatkozott rendezett forrástartományoknak érvényesnek kell lenniük; az összes mutatónak késleltethetőnek kell lennie, és az egyes sorozatokon belül az utolsó pozíciónak az elsőtől a növekményesen kell elérhetőnek lennie.

A céltartománynak nem szabad átfedésben lennie a forrástartományok egyikével sem, és elég nagynak kell lennie ahhoz, hogy tartalmazza a céltartományt.

A rendezett forrástartományokat az algoritmus alkalmazásának merge előfeltételeként kell elrendezni, az algoritmus által az egyesített tartományok rendezéséhez használt sorrend szerint.

A művelet stabil, mivel az egyes tartományok elemeinek relatív sorrendje megmarad a céltartományban. A forrástartományokat az algoritmus mergenem módosítja.

Az algoritmus összetettsége lineáris, legfeljebb (last1 - first1) - (last2 - first2) - 1 összehasonlítással.

Az list osztály egy tagfüggvényt merge biztosít két lista elemeinek egyesítéséhez.

példa

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

Két objektumot hasonlít össze, és a kettő közül a kisebbet adja vissza, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

left
Az összehasonlítandó két objektum közül az első.

right
A két összehasonlítandó objektum közül a második.

pred
A két objektum összehasonlítása bináris predikátum.

inlist
Az initializer_list összehasonlítandó tagokat tartalmazó.

Visszaadott érték

A két objektum közül a kisebb, hacsak egyik sem kisebb; ebben az esetben a két objektum közül az elsőt adja vissza. Ha meg van adva, initializer_list a listában szereplő objektumok közül a legkisebbet adja vissza.

Megjegyzések

Az min algoritmus szokatlan abban, hogy az objektumok paraméterekként vannak átadva. A legtöbb C++ standard kódtár-algoritmus számos olyan elemen működik, amelyek pozícióját paraméterekként átadott iterátorok határozzák meg. Ha olyan függvényre van szüksége, amely több elemből álló tartományt használ, használja a következőt min_element: . constexpr a Visual Studio 2017-ben engedélyezve initializer_list volt.

példa

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

Megkeresi a legkisebb elem első előfordulását egy megadott tartományban, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
A legkisebb elem kereséséhez használt tartomány első elemének pozícióját megadó forward iterátor.

last
Egy előremutató iterátor, amely a tartomány utolsó elemén egynél korábbi pozíciót kezel, és a legkisebb elemet keresi.

Visszaadott érték

Egy előremutató iterátor, amely a keresett tartomány legkisebb elemének első előfordulásának pozícióját kezeli.

Megjegyzések

Az összetettség lineáris: (last - first) - 1 összehasonlításra van szükség egy nem megfelelő tartományhoz.

példa

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

Egy hívással min_elementmax_element és egy hívással végzi el a munkát.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy tartomány elejét jelző továbbítási iterátor.

last
Egy tartomány végét jelző továbbítási iterátor.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az érzést, amelyben az egyik elem kisebb, mint a másik. Az összehasonlító predikátum két argumentumot vesz fel, és akkor kell visszaadnia true , ha az első kisebb, mint a második, és false ellenkező esetben.

Visszaadott érték

Visszatérítések

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

Megjegyzések

Az első sablonfüggvény visszaadja

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

A második sablonfüggvény ugyanúgy viselkedik, azzal a kivétellel, hogy lecseréli a következőre operator<(X, Y)pred(X, Y): .

Ha a sorozat nem üres, a függvény a legtöbb 3 * (last - first - 1) / 2 összehasonlítást végrehajtja.

`minmax`

Összehasonlít két bemeneti paramétert, és párként adja vissza őket, kisebb és nagyobb sorrendben.

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

Paraméterek

left
Az összehasonlítandó két objektum közül az első.

right
A két összehasonlítandó objektum közül a második.

pred
A két objektum összehasonlítása bináris predikátum.

inlist
Az initializer_list összehasonlítandó tagokat tartalmazó.

Megjegyzések

Az első sablonfüggvény akkor ad pair<const Type&, const Type&>( right, left ) vissza, ha right kisebb, mint left. Ellenkező esetben pair<const Type&, const Type&>( left, right )-et ad vissza.

A második tagfüggvény egy párot ad vissza, ahol az első elem a kisebb, a második pedig a nagyobb, ha összehasonlítjuk a predikátumot pred.

A többi sablonfüggvény ugyanúgy viselkedik, azzal a kivétellel, hogy a paramétereket és right a paramétereket a left következőre inlistcserélik.

A függvény pontosan egy összehasonlítást végez.

`mismatch`

Két tartományelemet hasonlít össze elem szerint, és megkeresi az első pozíciót, ahol a különbség bekövetkezik.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első tesztelendő tartomány első elemének pozícióját kezeli.

last1
Egy bemeneti iterátor, amely az első tesztelendő tartomány utolsó elemét megelőző pozíciót kezeli.

first2
Egy bemeneti iterátor, amely a tesztelendő második tartomány első elemének pozícióját kezeli.

last2
Egy bemeneti iterátor, amely a tesztelendő második tartomány utolsó elemén egynél korábbi pozícióval foglalkozik.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely összehasonlítja az egyes tartományok aktuális elemeit, és meghatározza, hogy azok egyenértékűek-e. Akkor tér true vissza, ha elégedett, és false ha nem elégedett.

Visszaadott érték

Egy iterátorpárt ad vissza, amely a két tartomány eltérési pozícióit kezeli. Az első összetevő iterátora az első tartomány helyére mutat. A második összetevő iterátora a második tartományban lévő pozícióra mutat. Ha nincs különbség az összehasonlított tartományok elemei között, vagy ha a második verzió bináris predikátumát a két tartomány összes elempárja kielégíti, akkor az első összetevő iterátora az első tartomány utolsó elemén túli pozícióra mutat, a második összetevő iterátora pedig egy olyan pozícióra mutat, amely a második tartományban tesztelt utolsó elemen túl van.

Megjegyzések

Az első sablonfüggvény feltételezi, hogy a tartománynak az első2-től kezdődően annyi eleme van, mint az [első1, utolsó1] által kijelölt tartománynak. Ha a második tartományban több is van, a rendszer figyelmen kívül hagyja őket; ha kevesebb van, akkor a nem definiált viselkedés eredménye.

A keresendő tartománynak érvényesnek kell lennie; az összes iterátornak el kell hareferensnek lennie, és az utolsó pozíció az elsőtől a növekményesen érhető el.

Az algoritmus időösszetettsége lineáris a rövidebb tartományban található elemek számában.

A felhasználó által definiált predikátumnak nem kell olyan egyenértékűségi relációt előírnia, amely szimmetrikus, reflexív és tranzitív az operandusok között.

példa

Az alábbi példa bemutatja, hogyan használható az eltérés. A C++03 túlterhelés csak azért jelenik meg, hogy bemutassuk, hogyan hozhat váratlan eredményt.

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

Adott tartományhoz társított elemek áthelyezése.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely jelzi, hogy hol kell elindítani az áthelyezni kívánt elemek tartományát.

last
Egy bemeneti iterátor, amely egy áthelyezendő elemtartomány végét jelzi.

dest
Az áthelyezett elemeket tartalmazó kimeneti iterátor.

Megjegyzések

A sablonfüggvény a tartományban [0, last - first)mindegyiknél N egyszer kiértékeli *(dest + N) = move(*(first + N)) az értékeket, így a legalacsonyabb értékkel kezdődő értékek N szigorúan növekednek. Ezután visszaadja a következőt dest + N: . Ha dest és first kijelöli a tárolási régiókat, dest akkor nem szabad a tartományon [first, last)belül lennie.

`move_backward`

Az egyik iterátor elemeit áthelyezi egy másikba. Az áthelyezés egy megadott tartomány utolsó elemével kezdődik, és a tartomány első elemével végződik.

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

Paraméterek

first
Egy iterátor, amely egy olyan tartomány kezdetét jelzi, amelyből elemeket helyezhet át.

last
Egy iterátor, amely egy tartomány végét jelzi az elemek áthelyezéséhez. Ez az elem nincs áthelyezve.

destEnd
Egy kétirányú iterátor, amely a céltartomány utolsó elemén egynél korábbi pozícióval foglalkozik.

Megjegyzések

A sablonfüggvény a tartományban [0, last - first)mindegyiknél N egyszer kiértékeli *(destEnd - N - 1) = move(*(last - N - 1)) az értékeket, így a legalacsonyabb értékkel kezdődő értékek N szigorúan növekednek. Ezután visszaadja a következőt destEnd - (last - first): . Ha destEnd és first kijelöli a tárolási régiókat, destEnd akkor nem szabad a tartományon [first, last)belül lennie.

move és move_backward funkcionálisan egyenértékűek az áthelyezési iterátor használatával copy és copy_backward használatával.

`next_permutation`

Átrendezi a tartomány elemeit, hogy az eredeti sorrendet a lexikográfiailag következő nagyobb permutáció váltsa fel, ha létezik. A lexikográfiai értelemben következő lehet meghatározni egy bináris predikátum.

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

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

Paraméterek

first
Kétirányú iterátor, amely a némítandó tartomány első elemének pozíciójára mutat.

last
Kétirányú iterátor, amely a némítandó tartomány utolsó eleméhez tartozó pozícióra mutat.

Visszaadott érték

true ha a lexikográfiailag következő permutáció létezik, és a tartomány eredeti sorrendjét felváltotta; ellenkező esetben falsea rendezés lexikográfiailag legkisebb permutációvá alakul át.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az alapértelmezett bináris predikátum kisebb, mint, és a tartomány elemeinek kisebbnek kell lenniük a összehasonlíthatónál, hogy a következő permutáció megfelelően legyen definiálva.

Az összetettség lineáris, legfeljebb (last - first) / 2 felcseréléssel.

példa

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

Az elemek egy tartományát particionálja, és helyesen tartalmazza a sorozat n. elemét abban a tartományban, amely megfelel ezeknek a feltételeknek: Az előtte lévő összes elem kisebb vagy egyenlő vele, és az azt követő összes elem nagyobb vagy egyenlő vele.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Véletlenszerű hozzáférésű iterátor, amely a particionálandó tartomány első elemének pozícióját kezeli.

nth
Véletlenszerű hozzáférésű iterátor, amely a partíció határán helyesen rendezendő elem pozícióját kezeli.

last
Egy véletlenszerű hozzáférésű iterátor, amely a particionálandó tartomány utolsó elemétől egynél korábbi pozíciót kezeli.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az nth_element algoritmus nem garantálja, hogy az alhálózatok elemei az nth elem mindkét oldalán rendezve vannak. Így kevesebb garanciát nyújt, mint partial_sorta kiválasztott elem alatti tartományban lévő elemek megrendelése, és gyorsabb alternatívaként partial_sort használható, ha az alacsonyabb tartomány sorrendbe helyezése nem szükséges.

Az elemek egyenértékűek, de nem feltétlenül egyenlők, ha egyik sem kisebb, mint a másik.

A rendezési összetettség átlaga lineáris last - firsta .

példa

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

Akkor adja true vissza, ha egy feltétel soha nem jelenik meg az adott tartomány elemei között.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely jelzi, hogy hol kezdjen el ellenőrizni egy feltétel egy elemtartományát.

last
Egy bemeneti iterátor, amely egy elemtartomány végét jelzi.

pred
A teszteléshez szükséges feltétel. Ezt a tesztet egy felhasználó által definiált predikátumfüggvény-objektum biztosítja, amely meghatározza a feltételt. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Visszaadja true , ha a feltételt legalább egyszer nem észleli a megadott tartományban, és false ha a feltételt észleli.

Megjegyzések

A sablonfüggvény csak akkor ad true vissza értéket, ha a tartomány [0, last - first)egy része N esetében a predikátum pred(*(first + N)) mindig false.

`partial_sort`

Egy tartomány kisebb elemeinek meghatározott számát rendezi növekvő sorrendbe. A bináris predikátumok rendezési feltételt adhatnak meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

sortEnd
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő altartomány utolsó eleméhez tartozó pozíciót kezeli.

last
Egy véletlenszerű hozzáférésű iterátor, amely a részben rendezendő tartomány utolsó elemétől egynél korábbi pozíciót kezeli.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az elemek egyenértékűek, de nem feltétlenül egyenlők, ha egyik sem kisebb, mint a másik. Az sort algoritmus nem stabil, és nem garantálja, hogy az egyenértékű elemek relatív sorrendje megmarad. Az algoritmus stable_sort megőrzi ezt az eredeti sorrendet.

A részleges rendezés átlagos összetettsége az O((last- first) napló (sortEnd- first)).

példa

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

Egy forrástartomány elemeit egy céltartományba másolja, ahol a forráselemeket kisebb vagy egy másik megadott bináris predikátum rendezi.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely a forrástartomány első elemének pozícióját kezeli.

last1
Egy bemeneti iterátor, amely a forrástartomány utolsó eleméhez tartozó pozíciót kezeli.

first2
Véletlenszerű hozzáférésű iterátor, amely a rendezett céltartomány első elemének pozícióját kezeli.

last2
Véletlenszerű hozzáférésű iterátor, amely a rendezési céltartomány utolsó elemétől egynél korábbi pozíciót kezeli.

Visszaadott érték

Egy véletlenszerű hozzáférésű iterátor, amely a céltartományban lévő elemet a forrástartományból beszúrt utolsó elemen túli pozícióval kezeli.

Megjegyzések

A forrás- és céltartományok nem lehetnek átfedésben, és érvényesnek kell lenniük; az összes mutatónak késleltethetőnek kell lennie, és az egyes sorozatokon belül az utolsó pozíciónak az elsőtől a növekményesen kell elérhetőnek lennie.

A bináris predikátumnak szigorúan gyenge sorrendet kell biztosítania, hogy a nem egyenértékű elemek sorrendbe legyenek rendezve, de az egyenértékű elemek nem. Két elem kisebb, de nem feltétlenül egyenlő, ha egyik sem kisebb, mint a másik.

példa

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

A tartomány elemeit két különálló halmazba sorolja be, és ezek az elemek kielégítenek egy nem meghatározott predikátumot, amely megelőzi azokat, amelyek nem teljesítik azt.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Kétirányú iterátor, amely a particionálandó tartomány első elemének pozícióját kezeli.

last
Kétirányú iterátor, amely a particionálandó tartomány utolsó elemétől egynél korábbi pozíciót kezeli.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt a feltételt, hogy teljesüljön egy elem besorolása. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Kétirányú iterátor, amely a tartomány első elemének pozícióját kezeli, hogy ne feleljen meg a predikátum feltételének.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az elemek a és b egyenértékűek, de nem feltétlenül egyenlők, ha mindkettő pred( a, b ) hamis és pred( b, a ) hamis, ahol pred a paraméter által megadott predikátum van. Az partition algoritmus nem stabil, és nem garantálja, hogy az egyenértékű elemek relatív sorrendje megmarad. Az algoritmus stable_partition megőrzi ezt az eredeti sorrendet.

Az összetettség lineáris: vannak (last - first) alkalmazások pred , és legfeljebb (last - first)/2 felcserélések.

példa

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

Olyan elemek másolása, amelyekhez egy feltétel egy célhelyre tartozik true , és amelyekhez a feltétel egy másikhoz tartozik false . Az elemeknek egy megadott tartományból kell származnia.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely egy feltétel ellenőrzésére szolgáló tartomány elejét jelzi.

last
Egy tartomány végét jelző bemeneti iterátor.

dest1
Egy kimeneti iterátor, amellyel azokat az elemeket másolhatja, amelyek igaz értéket adnak vissza egy, a használatával predtesztelt feltételhez.

dest2
Egy kimeneti iterátor, amely hamis eredményt ad vissza egy, a használatával predtesztelt feltételhez.

pred
A teszteléshez szükséges feltétel. A tesztet egy felhasználó által definiált predikátumfüggvény-objektum biztosítja, amely meghatározza a tesztelni kívánt feltételt. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Megjegyzések

A sablonfüggvény minden elemet X[first,last) bemásolja, ha *dest1++pred(X) igaz, vagy *dest2++ ha nem. Visszaadja a pair<OutputIterator1, OutputIterator2>(dest1, dest2) értéket.

`partition_point`

A megadott tartomány első olyan elemét adja vissza, amely nem felel meg a feltételnek. Az elemek úgy vannak rendezve, hogy azok, amelyek megfelelnek a feltételnek, azok elé kerülnek, amelyek nem.

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

Paraméterek

first
A ForwardIterator feltétel ellenőrzésére szolgáló tartomány kezdetét jelzi.

last
A ForwardIterator tartomány végét jelző érték.

pred
A teszteléshez szükséges feltétel. A tesztet egy felhasználó által definiált predikátumfüggvény-objektum biztosítja, amely meghatározza azt a feltételt, amelyet a keresett elemnek teljesítenie kell. A nem jegyző predikátumok egyetlen argumentumot vesznek fel, és visszaadják true vagy false.

Visszaadott érték

Olyan értéket ad ForwardIterator vissza, amely az első olyan elemre hivatkozik, amely nem felel meg a tesztelt predfeltételnek, vagy ha nem található, akkor visszaadja last .

Megjegyzések

A sablonfüggvény megkeresi az első iterátort it[first, last) , amelyben pred(*it) az van false. A sorrendet a következő szerint kell rendezni pred: .

`pop_heap`

Eltávolítja a legnagyobb elemet a halom elejéről az utolsó előtti pozícióba a tartományban, majd új halomot hoz létre a többi elemből.

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

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

Paraméterek

first
Véletlenszerű hozzáférésű iterátor, amely a halom első elemének pozícióját kezeli.

last
Egy véletlenszerű hozzáférésű iterátor, amely a halom utolsó elemétől egynél korábbi pozícióval foglalkozik.

Megjegyzések

Az pop_heap algoritmus az push_heap algoritmus által végrehajtott művelet inverze, amelyben egy tartomány utolsó előtti pozíciójában lévő elemet adnak hozzá egy halomhoz, amely a tartomány korábbi elemeiből áll, abban az esetben, ha a halomhoz hozzáadott elem nagyobb, mint a halomban lévő elemek bármelyike.

A halmok két tulajdonsággal rendelkeznek:

Az első elem mindig a legnagyobb.
Az elemek logaritmikus időben hozzáadhatók vagy eltávolíthatók.

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az újonnan hozzáadott elemet kizáró tartománynak halomnak kell lennie.

Az összetettség logaritmikus, amely a legtöbb log (last - first) összehasonlítást igényli.

példa

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

Átrendezi egy tartomány elemeit, hogy az eredeti sorrendet a lexikográfiailag korábbi nagyobb permutáció váltsa fel, ha létezik. A bináris predikátum meghatározhatja a lexikográfiai szempontból korábbi érzetet.

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

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

Paraméterek

first
Kétirányú iterátor, amely a némítandó tartomány első elemének pozíciójára mutat.

last
Kétirányú iterátor, amely a némítandó tartomány utolsó eleméhez tartozó pozícióra mutat.

Visszaadott érték

true ha a lexikálisan korábbi permutáció létezik, és a tartomány eredeti sorrendjét felváltotta; ellenkező esetben falsea rendezés lexikográfiailag legnagyobb permutációvá alakul át.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az alapértelmezett bináris predikátum kisebb, mint a tartomány elemeinek összehasonlíthatónak kell lenniük, hogy az előző permutáció megfelelően legyen definiálva.

Az összetettség lineáris, legfeljebb (last - first)/2 felcseréléssel.

példa

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

Egy tartomány végén lévő elemet ad hozzá egy meglévő halomhoz, amely a tartomány korábbi elemeiből áll.

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

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

Paraméterek

first
Véletlenszerű hozzáférésű iterátor, amely a halom első elemének pozícióját kezeli.

last
Egy véletlenszerű hozzáférésű iterátor, amely egy olyan pozíciót kezel, amely a tartomány utolsó elemét egy halommá alakítja.

Megjegyzések

Az elemet először vissza kell küldeni egy meglévő halom végéhez, majd az algoritmus használatával adja hozzá ezt az elemet a meglévő halomhoz.

A halmok két tulajdonsággal rendelkeznek:

Az első elem mindig a legnagyobb.
Az elemek logaritmikus időben hozzáadhatók vagy eltávolíthatók.

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az újonnan hozzáadott elemet kizáró tartománynak halomnak kell lennie.

Az összetettség logaritmikus, amely a legtöbb log(last - first) összehasonlítást igényli.

példa

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

A std::random_shuffle() függvény elavult, helyébe a következő lép std::shuffle: . Egy példakódra és további információra a <random> Stack Overflow post Why are std::random_shuffle is deprecated in C++14?.

`remove`

Egy megadott érték eltávolítása egy adott tartományból a fennmaradó elemek sorrendjének megzavarása nélkül. A megadott érték nélküli új tartomány végét adja vissza.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy továbbítási iterátor, amely a tartomány első elemének pozícióját kezeli, amelyből az elemeket eltávolítják.

last
Egy előremutató iterátor, amely a tartomány utolsó eleméhez tartozó pozíciót kezeli, amelyből az elemeket eltávolítják.

value
A tartományból eltávolítandó érték.

Visszaadott érték

A módosított tartomány új végpozícióját kezelő forward iterátor, amely a megadott érték nélküli maradványütemezés utolsó elemén túl van.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A nem eltávolított elemek sorrendje stabil marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja (last - first) az egyenlőséget.

Az list osztály egy hatékonyabb tagfüggvény-verzióval rendelkezik remove, amely a mutatókat is újraklinkeli.

példa

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

Elemeket másol egy forrástartományból egy céltartományba, azzal a kivételrel, hogy egy megadott érték elemei nem lesznek másolva, a többi elem sorrendjének megzavarása nélkül. Egy új céltartomány végét adja vissza.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely annak a tartománynak az első elemét kezeli, amelyből az elemeket eltávolítják.

last
Egy bemeneti iterátor, amely azt a pozíciót kezeli, amely a tartomány utolsó eleme mellett található, ahonnan az elemeket eltávolítják.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli, amelybe az elemeket eltávolítják.

value
A tartományból eltávolítandó érték.

Visszaadott érték

A céltartomány új végpozícióját kezelő forward iterator, amely a megadott érték nélküli maradványütemezés másolatának utolsó eleme mellett található.

Megjegyzések

A hivatkozott forrás- és céltartományoknak érvényesnek kell lenniük; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A céltartományban elegendő helynek kell lennie ahhoz, hogy tartalmazza a megadott érték elemeinek eltávolítása után másolni kívánt maradványelemeket.

A nem eltávolított elemek sorrendje stabil marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja azlast - first egyenlőséget és legfeljebb (last - first) a feladatokat.

példa

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

Elemeket másol egy forrástartományból egy céltartományba, kivéve azokat az elemeket, amelyek megfelelnek egy predikátumnak. Az elemek másolása a többi elem sorrendjének megzavarása nélkül. Egy új céltartomány végét adja vissza.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely annak a tartománynak az első elemét kezeli, amelyből az elemeket eltávolítják.

last
Egy bemeneti iterátor, amely azt a pozíciót kezeli, amely a tartomány utolsó eleme mellett található, ahonnan az elemeket eltávolítják.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli, amelybe az elemeket eltávolítják.

pred
Az kielégítendő unary predikátum az elem értékét kell lecserélni.

Visszaadott érték

A céltartomány új végpozícióját kezelő forward iterátor, amely a predikátumnak megfelelő elemeket nem tartalmazó maradványütemezés utolsó elemén múlt.

Megjegyzések

A hivatkozott forrástartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A céltartományban elegendő helynek kell lennie ahhoz, hogy tartalmazza a megadott érték elemeinek eltávolítása után másolni kívánt maradványelemeket.

A nem eltávolított elemek sorrendje stabil marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja azlast - first egyenlőséget és legfeljebb (last - first) a feladatokat.

A függvények működéséről további információt a Ellenőrzött iterátorok című témakörben talál.

példa

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

Kiküszöböli azokat az elemeket, amelyek megfelelnek egy predikátumnak egy adott tartományból anélkül, hogy megzavarnák a fennmaradó elemek sorrendjét. A megadott érték nélküli új tartomány végét adja vissza.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy előremutató iterátor, amely annak a tartománynak az első elemére mutat, amelyből az elemek el lesznek távolítva.

last
Egy előremutató iterátor, amely az elemek eltávolításának tartományában lévő utolsó elemen kívülre mutat.

pred
Az kielégítendő unary predikátum az elem értékét kell lecserélni.

Visszaadott érték

A módosított tartomány új végpozícióját kezelő forward iterátor, amely a megadott érték nélküli maradványütemezés utolsó elemén túl van.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A nem eltávolított elemek sorrendje stabil marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja (last - first) az egyenlőséget.

A listának hatékonyabb tagfüggvény-verziója van az eltávolításnak, amely újrakontrasztja a mutatókat.

példa

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

Megvizsgálja egy tartomány minden elemét, és lecseréli, ha megfelel egy megadott értéknek.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy előremutató iterátor, amely annak a tartománynak az első elemére mutat, amelyből az elemeket lecserélik.

last
Egy előremutató iterátor, amely egy olyan pozícióra mutat, amely az elemek cseréjének tartományában lévő utolsó elemen kívülre mutat.

oldVal
A lecserélt elemek régi értéke.

newVal
A régi értékkel rendelkező elemekhez hozzárendelt új érték.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A fel nem cserélt elemek sorrendje változatlan marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja (last - first) az egyenlőséget, és legfeljebb (last - first) új értékek hozzárendelését.

példa

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

Megvizsgálja egy forrástartomány minden elemét, és lecseréli, ha megfelel egy megadott értéknek, miközben az eredményt egy új céltartományba másolja.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely annak a tartománynak az első elemére mutat, amelyből az elemeket lecserélik.

last
Egy bemeneti iterátor, amely arra a pozícióra mutat, amely a tartomány utolsó eleme mellett található, ahonnan az elemeket lecserélik.

result
Egy kimeneti iterátor, amely a céltartomány első elemére mutat arra a helyre, ahol az elemek módosított sorozata másolása történik.

oldVal
A lecserélt elemek régi értéke.

newVal
A régi értékkel rendelkező elemekhez hozzárendelt új érték.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemén egynél korábbi pozícióra mutat, a program az elemek módosított sorozatát másolja a céltartományba.

Megjegyzések

A hivatkozott forrás- és céltartományok nem lehetnek átfedésben, és mindkettőnek érvényesnek kell lenniük: az összes mutatónak késleltethetőnek kell lennie, és a sorozatokon belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A fel nem cserélt elemek sorrendje változatlan marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja (last - first) az egyenlőséget, és legfeljebb (last - first) új értékek hozzárendelését.

példa

// alg_replace_copy.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> theVector;
    list<int> theList(15);

    for (int i = 0; i <= 9; i++)
    {
        theVector.push_back(i);
    }

    for (int i = 0; i <= 3; i++)
    {
        theVector.push_back(7);
    }

    random_shuffle(theVector.begin(), theVector.end());
	
    for (int i = 0; i <= 15; i++)
    {
        theVector.push_back(1);
    }

    cout << "The shuffled vector:\n ( ";
    for (auto iter = theVector.begin(); iter != theVector.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;

    // Replace the 7s in part of the vector with 70s
    // and copy into another part of the vector
    replace_copy(theVector.begin(), theVector.begin() + 14, theVector.end() - 15, 7, 70);

    cout << "The vector with instances of 7 replaced with 70 starting at position 14:\n ( ";
    for (auto iter = theVector.begin(); iter != theVector.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;

    // Replace 7s found in the first 14 positions in the vector with 1s and then copy the result into a list
    replace_copy(theVector.begin(), theVector.begin() + 14, theList.begin(), 7, 1);

    cout << "List containing the contents of the vector but 7s replaced with 1s.\n ( ";
    for (auto iter = theList.begin(); iter != theList.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << ")." << endl;
}

random_shuffle() Az előző kódban szereplő hívás miatt a kimenet eltérő lehet.

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`

Megvizsgálja egy forrástartomány egyes elemeit, és lecseréli azt, ha megfelel egy adott predikátumnak, miközben az eredményt egy új céltartományba másolja.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely annak a tartománynak az első elemére mutat, amelyből az elemeket lecserélik.

last
Egy bemeneti iterátor, amely arra a pozícióra mutat, amely a tartomány utolsó eleme mellett található, ahonnan az elemeket lecserélik.

result
Egy kimeneti iterátor, amely annak a céltartománynak az első elemére mutat, amelybe az elemeket másolja.

pred
Az kielégítendő unary predikátum az elem értékét kell lecserélni.

value
Az új érték azokhoz az elemekhez lesz hozzárendelve, amelyek régi értéke megfelel a predikátumnak.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemén egynél korábbi pozícióra mutat, a program az elemek módosított sorozatát másolja a céltartományba.

Megjegyzések

A fel nem cserélt elemek sorrendje változatlan marad.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja (last - first) az egyenlőséget, és legfeljebb (last - first) új értékek hozzárendelését.

példa

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

Megvizsgálja egy tartomány egyes elemeit, és lecseréli, ha megfelel egy adott predikátumnak.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy előremutató iterátor, amely annak a tartománynak az első elemére mutat, amelyből az elemeket lecserélik.

last
Egy iterátor, amely arra a pozícióra mutat, amely a tartomány utolsó eleme mellett található, ahonnan az elemeket lecserélik.

pred
Az kielégítendő unary predikátum az elem értékét kell lecserélni.

value
Az új érték azokhoz az elemekhez lesz hozzárendelve, amelyek régi értéke megfelel a predikátumnak.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A fel nem cserélt elemek sorrendje változatlan marad.

Az algoritmus replace_if az algoritmus replaceáltalánosítása, amely lehetővé teszi a predikátumok megadását, nem pedig egy adott állandó értékhez való egyenlőséget.

Az operator== elemek közötti egyenlőség meghatározásához használt elemeknek egyenértékűségi relációt kell előírniuk az operandusok között.

Az összetettség lineáris. Összehasonlítja (last - first) az egyenlőséget, és legfeljebb (last - first) új értékek hozzárendelését.

példa

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

A tartományon belüli elemek sorrendjének megfordítása.

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

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Kétirányú iterátor, amely annak a tartománynak az első elemére mutat, amelyen belül az elemek elnémulnak.

last
Kétirányú iterátor, amely az elemek áthatolásának tartományában lévő utolsó elemen kívüli pozícióra mutat.

Megjegyzések

példa

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

Megfordítja a forrástartomány elemeinek sorrendjét, miközben a céltartományba másolja őket

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Kétirányú iterátor, amely annak a forrástartománynak az első elemére mutat, amelyen belül az elemek elnémulnak.

last
Kétirányú iterátor, amely a forrástartomány utolsó eleméhez tartozó pozícióra mutat, amelyen belül az elemek elnémulnak.

result
Egy kimeneti iterátor, amely annak a céltartománynak az első elemére mutat, amelybe az elemeket másolja.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemén egynél korábbi pozícióra mutat, a program az elemek módosított sorozatát másolja a céltartományba.

Megjegyzések

példa

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

Két szomszédos tartomány elemeit cseréli le.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
A elforgatni kívánt tartomány első elemének pozícióját megadó forward iterátor.

middle
A tartományon belüli határt meghatározó forward iterátor, amely a tartomány második részének első elemének pozícióját kezeli, amelynek elemeit a tartomány első részében lévőkkel kell kicserélni.

last
Egy előremutató iterátor, amely a elforgatni kívánt tartomány utolsó elemétől egy korábbi pozíciót kezeli.

Megjegyzések

A hivatkozott tartományoknak érvényesnek kell lenniük; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az összetettség lineáris. Legfeljebb (last - first) csereügyleteket végez.

példa

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

Egy forrástartomány két szomszédos tartományának elemeit cseréli le, és az eredményt egy céltartományba másolja.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
A elforgatni kívánt tartomány első elemének pozícióját megadó forward iterátor.

last
Egy előremutató iterátor, amely a elforgatni kívánt tartomány utolsó elemétől egy korábbi pozíciót kezeli.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó eleme mellett lévő pozíciót kezeli.

Megjegyzések

Az összetettség lineáris. Legfeljebb (last - first) csereügyleteket végez.

példa

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

Olyan sorozat első előfordulását keresi egy céltartományon belül, amelynek elemei megegyeznek az adott elemsorozat elemeivel, vagy amelyek elemei az adott sorozat elemeire vonatkozó bináris predikátum által meghatározott értelemben egyenértékűek.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last1
Egy előremutató iterátor, amely a keresendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

first2
Egy forward iterator, amely a egyeztetendő tartomány első elemének pozícióját kezeli.

last2
Egy előremutató iterátor, amely a megfeleltetendő tartomány utolsó elemén egynél korábbi pozícióval foglalkozik.

searcher
A keresendő mintát és a használni kívánt keresési algoritmust tartalmazó kereső. A keresőkkel kapcsolatos további információkért tekintse meg default_searcher az osztályt, boyer_moore_horspool_searcher az osztályt és boyer_moore_searcher az osztályt.

Visszaadott érték

A megadott sorrendnek megfelelő vagy a bináris predikátum által meghatározott értelemben egyenértékű első részhalmaz első elemének pozícióját megadó forward iterátor.

Megjegyzések

Az operator== elem és a megadott érték közötti egyezés meghatározásához használtnak egyenértékűségi kapcsolatot kell megállapítania az operandusok között.

A hivatkozott tartományoknak érvényesnek kell lenniük; az összes mutatónak késleltethetőnek kell lennie, és minden sorozaton belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az átlagos összetettség lineáris a keresett tartomány méretéhez képest. A legrosszabb eset összetettsége is lineáris a keresett sorozat méretéhez képest.

példa

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

Megkeresi az első részhalmazt egy adott számú elemből álló tartományban, amely egy adott értékkel vagy egy bináris predikátumban megadott értékhez való viszonysal rendelkezik.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy továbbító iterátor, amely a keresendő tartomány első elemének pozícióját kezeli.

last1
Egy előremutató iterátor, amely a keresendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

count
A keresett alhálózat mérete.

value
A keresett sorozat elemeinek értéke.

Visszaadott érték

A megadott sorrendnek megfelelő vagy a bináris predikátum által meghatározott értelemben egyenértékű első részhalmaz első elemének pozícióját megadó forward iterátor.

Megjegyzések

Az operator== elem és a megadott érték közötti egyezés meghatározásához használtnak egyenértékűségi kapcsolatot kell megállapítania az operandusok között.

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

A komplexitás lineáris a keresett méret szempontjából.

példa

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

Egyesít minden olyan elemet, amely egy rendezett forrástartományhoz tartozik, de nem egy második rendezett forrástartományhoz, egyetlen, rendezett céltartományba. A bináris predikátum meghatározhatja a rendezési feltételt.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első két rendezésű forrástartomány első elemének pozícióját kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány különbségét képviseli.

last1
Egy bemeneti iterátor, amely az első két rendezési forrástartomány utolsó elemét megelőző pozíciót kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány különbségét képviseli.

first2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második részének első elemének pozícióját kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány különbségét képviseli.

last2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második utolsó elemén egynél korábbi pozíciót kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány különbségét képviseli.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli, ahol a két forrástartományt egyetlen rendezett tartományba kell egyesíteni, amely a két forrástartomány különbségét képviseli.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az érzést, amelyben az egyik elem kisebb, mint a másik. A bináris predikátum két argumentumot vesz fel, és akkor kell visszaadnia true , ha az első elem kisebb, mint a második elem, és false ellenkező esetben.

Visszaadott érték

Egy kimeneti iterátor, amely a rendezési céltartomány utolsó elemétől egynél korábbi pozíciót ad meg, amely a két forrástartomány különbségét jelöli.

Megjegyzések

A céltartománynak nem szabad átfedésben lennie a forrástartományok egyikével sem, és elég nagynak kell lennie ahhoz, hogy az első forrástartományt tartalmazza.

A rendezett forrástartományokat az algoritmus alkalmazásának set_difference előfeltételeként kell elrendezni, az algoritmus által az egyesített tartományok rendezéséhez használt sorrend szerint.

A művelet stabil, mivel az egyes tartományok elemeinek relatív sorrendje megmarad a céltartományban. A forrástartományokat az algoritmus egyesítése nem módosítja.

A bemeneti iterátorok értéktípusainak kisebbnek kell lenniük, mint a rendezendőknek. Vagyis két elem alapján megállapíthatja, hogy az egyik kisebb a másiknál, vagy egyenértékű. (Itt az egyenértékű azt jelenti, hogy egyik sem kisebb, mint a másik.) Ez az összehasonlítás a nem megfelelő elemek közötti sorrendet eredményezi. Ha mindkét forrástartományban azonos elemek találhatók, az első tartomány elemei megelőzik a céltartomány második forrástartományának elemeit. Ha a forrástartományok olyan elemek duplikáltjait tartalmazzák, hogy az első forrástartományban több van, mint a másodikban, akkor a céltartomány azt a számot fogja tartalmazni, amellyel az első forrástartományban lévő elemek előfordulásai meghaladják a második forrástartományban található elemek előfordulásait.

Az algoritmus összetettsége lineáris, legfeljebb 2 * ((last1 - first1) + (last2 - first2)) - 1 egyetlen forrástartomány összehasonlításával.

példa

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

Egyesíti a mindkét rendezett forrástartományhoz tartozó összes elemet egyetlen, rendezett céltartományba, ahol a rendezési feltételt bináris predikátum határozhatja meg.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első két rendezett forrástartomány első elemének pozícióját kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány metszetét jelöli.

last1
Egy bemeneti iterátor, amely az első két rendezési forrástartomány utolsó eleménél korábbi pozíciót kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány metszetét jelöli.

last2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második utolsó eleménél korábbi pozíciót kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány metszetét jelöli.

Visszaadott érték

Egy kimeneti iterátor, amely a két forrástartomány metszetét képviselő rendezési céltartomány utolsó eleménél egynél korábbi pozíciót kezeli.

Megjegyzések

A céltartománynak nem szabad átfedésben lennie a forrástartományok egyikével sem, és elég nagynak kell lennie ahhoz, hogy tartalmazza a céltartományt.

A rendezett forrástartományokat az egyesítési algoritmus alkalmazásának előfeltételeként kell elrendezni az algoritmus által az egyesített tartományok rendezéséhez használt sorrend szerint.

A művelet stabil, mivel az egyes tartományok elemeinek relatív sorrendje megmarad a céltartományban. A forrástartományokat az algoritmus nem módosítja.

A bemeneti iterátorok értéktípusainak kisebbnek kell lenniük, mint a rendezendőknek. Vagyis két elem alapján megállapíthatja, hogy az egyik kisebb a másiknál, vagy egyenértékű. (Itt az egyenértékű azt jelenti, hogy egyik sem kisebb, mint a másik.) Ez az összehasonlítás a nem megfelelő elemek közötti sorrendet eredményezi. Ha mindkét forrástartományban azonos elemek találhatók, az első tartomány elemei megelőzik a céltartomány második forrástartományának elemeit. Ha a forrástartományok egy elem duplikáltjait tartalmazzák, akkor a céltartomány a két forrástartományban előforduló elemek maximális számát fogja tartalmazni.

Az algoritmus összetettsége lineáris, legfeljebb 2 * ((last1 - first1) + (last2 - first2)) - 1 egyetlen forrástartomány összehasonlításával.

példa

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

Egyesít minden olyan elemet, amely a rendezett forrástartományok egyikéhez tartozik, de nem mindkettőhöz, egyetlen, rendezett céltartományba. A bináris predikátum meghatározhatja a rendezési feltételt.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely a két rendezésű forrástartomány első elemének pozícióját kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány szimmetrikus különbségét képviseli.

last1
Egy bemeneti iterátor, amely az első két rendezési forrástartomány utolsó elemén egynél korábbi pozíciót kezel, és egyetlen tartományba rendezi, amely a két forrástartomány szimmetrikus különbségét képviseli.

last2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második utolsó elemén túllépő pozíciót kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány szimmetrikus különbségét képviseli.

Visszaadott érték

Egy kimeneti iterátor, amely a két forrástartomány szimmetrikus különbségét képviselő rendezési céltartomány utolsó elemén egynél korábbi pozíciót kezel.

Megjegyzések

A céltartománynak nem szabad átfedésben lennie a forrástartományok egyikével sem, és elég nagynak kell lennie ahhoz, hogy tartalmazza a céltartományt.

A rendezett forrástartományokat az algoritmus alkalmazásának merge* előfeltételeként kell elrendezni, az algoritmus által az egyesített tartományok rendezéséhez használt sorrend szerint.

A művelet stabil, mivel az egyes tartományok elemeinek relatív sorrendje megmarad a céltartományban. A forrástartományokat az algoritmus egyesítése nem módosítja.

A bemeneti iterátorok értéktípusainak kisebbnek kell lenniük, mint a rendezendőknek. Vagyis két elem alapján megállapíthatja, hogy az egyik kisebb a másiknál, vagy egyenértékű. (Itt az egyenértékű azt jelenti, hogy egyik sem kisebb, mint a másik.) Ez az összehasonlítás a nem megfelelő elemek közötti sorrendet eredményezi. Ha mindkét forrástartományban azonos elemek találhatók, az első tartomány elemei megelőzik a céltartomány második forrástartományának elemeit. Ha a forrástartományok egy elem duplikált értékeit tartalmazzák, akkor a céltartomány annak a számnak az abszolút értékét fogja tartalmazni, amellyel az egyik forrástartomány elemeinek előfordulása meghaladja a második forrástartomány elemeinek előfordulásait.

Az algoritmus összetettsége lineáris, legfeljebb 2 * ((last1 - first1) + (last2 - first2)) - 1 egyetlen forrástartomány összehasonlításával.

példa

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

A két rendezett forrástartomány legalább egyikéhez tartozó összes elemet egyetlen, rendezett céltartományba egyesíti. A bináris predikátum meghatározhatja a rendezési feltételt.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

last1
Egy bemeneti iterátor, amely az első két rendezett forrástartomány utolsó elemén egynél korábbi pozíciót kezel, és egyetlen tartományba rendezi, amely a két forrástartomány egyesítését jelöli.

last2
Egy bemeneti iterátor, amely a két egymást követő rendezési forrástartomány második utolsó elemén múlt pozíciót kezeli, és egyetlen tartományba rendezi, amely a két forrástartomány egyesítését jelöli.

Visszaadott érték

Egy kimeneti iterátor, amely a két forrástartomány egyesítését jelképező rendezési céltartomány utolsó elemén túllépő pozíciót kezeli.

Megjegyzések

A céltartománynak nem szabad átfedésben lennie a forrástartományok egyikével sem, és elég nagynak kell lennie ahhoz, hogy tartalmazza a céltartományt.

A művelet stabil, mivel az egyes tartományok elemeinek relatív sorrendje megmarad a céltartományban. A forrástartományokat az algoritmus mergenem módosítja.

A bemeneti iterátorok értéktípusainak kisebbnek kell lenniük, mint a rendezendőknek. Vagyis két elem alapján megállapíthatja, hogy az egyik kisebb a másiknál, vagy egyenértékű. (Itt az egyenértékű azt jelenti, hogy egyik sem kisebb, mint a másik.) Ez az összehasonlítás a nem megfelelő elemek közötti sorrendet eredményezi. Ha mindkét forrástartományban azonos elemek találhatók, az első tartomány elemei megelőzik a céltartomány második forrástartományának elemeit. Ha a forrástartományok egy elem duplikáltjait tartalmazzák, akkor a céltartomány a két forrástartományban előforduló elemek maximális számát fogja tartalmazni.

Az algoritmus összetettsége lineáris, legfeljebb 2 * ((last1 - first1) + (last2 - first2)) - 1 összehasonlítással.

példa

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

Egy adott tartomány elemeinek átrendezése véletlenszerű számgenerátor használatával.

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

Paraméterek

first
Iterátor az elegyíteni kívánt tartomány első eleméhez, beleértve azokat is. Meg kell felelnie a követelményeknek RandomAccessIterator és ValueSwappable.

last
Egy iterátor a tartomány utolsó eleméhez, amely el van keverődve, kizárólagos. Meg kell felelnie a követelményeknek RandomAccessIterator és ValueSwappable.

gen
A függvény által a shuffle() művelethez használt véletlenszerű számgenerátor. Meg kell felelnie UniformRandomNumberGeneratoregy .

Megjegyzések

További információkért és a használt shuffle()kódmintáért lásd: <random>.

`sort`

Egy megadott tartomány elemeit nem növekvő sorrendbe vagy egy bináris predikátum által megadott rendezési feltétel szerint rendezi.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

last
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az összehasonlítási feltételt, amelyet a rendezés egymást követő elemeinek teljesítenie kell. Ez a bináris predikátum két argumentumot vesz fel, és akkor ad vissza, true ha a két argumentum sorrendben van, és false ellenkező esetben. Ennek az összehasonlító függvénynek szigorúan gyenge sorrendet kell szabnia a sorozat elemeinek párjaira. További információ: Algoritmusok.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az elemek egyenértékűek, de nem feltétlenül egyenlők, ha egyik sem kisebb, mint a másik. Az sort algoritmus nem stabil, ezért nem garantálja, hogy az egyenértékű elemek relatív sorrendje megmarad. Az algoritmus stable_sort megőrzi ezt az eredeti sorrendet.

A rendezési összetettség átlaga az O( N log N ), ahol N = last - first.

példa

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

Egy halom rendezett tartománylá alakít át.

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

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

Paraméterek

first
Egy véletlenszerű hozzáférésű iterátor, amely a cél halom első elemének pozícióját kezeli.

last
Egy véletlenszerű hozzáférésű iterátor, amely a cél halom utolsó elemétől egynél korábbi pozícióval foglalkozik.

Megjegyzések

A halmok két tulajdonsággal rendelkeznek:

Az első elem mindig a legnagyobb.
Az elemek logaritmikus időben hozzáadhatók vagy eltávolíthatók.

Az alkalmazás után, ha ez az algoritmus, az alkalmazott tartomány már nem halom.

sort_heap nem stabil rendezés, mert az egyenértékű elemek relatív sorrendje nem feltétlenül marad meg.

A halmok ideális megoldást jelentenek a prioritási üzenetsorok implementálásához, és a C++ Standard Kódtár tárolóadapetorosztályának priority_queueimplementálásához használják őket.

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az összetettség legfeljebb N log Nott van, ahol N = last - first.

példa

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

A tartomány elemeit két különálló halmazba sorolja be, azokat az elemeket, amelyek kielégítenek egy nem kívánt predikátumot, megelőzve azokat, amelyek nem elégítik ki őket, megőrizve az egyenértékű elemek relatív sorrendjét.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Kétirányú iterátor, amely a particionálandó tartomány első elemének pozícióját kezeli.

last
Kétirányú iterátor, amely a particionálandó tartomány utolsó elemétől egynél korábbi pozíciót kezeli.

pred
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt a feltételt, hogy teljesüljön egy elem besorolása. A nem jegyző predikátumok egyetlen argumentumot használnak, és akkor ad vissza true , ha teljesülnek, vagy false ha nem teljesülnek.

Visszaadott érték

Kétirányú iterátor, amely a tartomány első elemének pozícióját kezeli, hogy ne feleljen meg a predikátum feltételének.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az a és b elemek egyenértékűek, de nem feltétlenül egyenlők, ha mindkettő pred( a, b ) hamis és pred( b, a ) hamis, ahol pred a paraméter által megadott predikátum van. Az stable_partition algoritmus stabil, és garantálja, hogy az egyenértékű elemek relatív sorrendje megmarad. Az algoritmus partition nem feltétlenül őrzi meg ezt az eredeti rendezést.

példa

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

Egy megadott tartomány elemeit nem növekvő sorrendbe vagy egy bináris predikátum által megadott rendezési feltétel szerint rendezi. Megőrzi az egyenértékű elemek relatív sorrendjét.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Kétirányú iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

last
Kétirányú iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

Megjegyzések

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az elemek egyenértékűek, de nem feltétlenül egyenlők, ha egyik sem kisebb, mint a másik. Az sort algoritmus stabil, és garantálja, hogy az egyenértékű elemek relatív sorrendje megmarad.

A futásidejű stable_sort összetettség a rendelkezésre álló memória mennyiségétől függ, de a legjobb eset (elegendő memória) és O(N log N) a legrosszabb esetben az O(N (log N)^2)N = last - first. Az algoritmus általában gyorsabb, sort mint stable_sorta .

példa

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

Az első felülbírálás két objektum értékeit cseréli le. A második felülbírálás két objektumtömb között cseréli le az értékeket.

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

Paraméterek

left
Az első felülbírálás esetében az első objektum, amely kicseréli a tartalmát. A második felülbírálásnál az objektumok első tömbje kicseréli a tartalmát.

right
Az első felülbírálás esetén a második objektum, amely a tartalmát kicseréli. A második felülbírálás esetén az objektumok második tömbje kicseréli a tartalmát.

Megjegyzések

Az első túlterhelést úgy tervezték, hogy az egyes objektumokon működjön. A második túlterhelés felcseréli az objektumok tartalmát két tömb között.

példa

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

Az egyik tartomány elemeit egy másik, egyenlő méretű tartomány elemeivel cseréli le.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy előremutató iterátor, amely annak az első tartománynak az első pozíciójára mutat, amelynek elemeit cserélni kell.

last1
Egy előremutató iterátor, amely az első olyan tartomány utolsó pozícióján múlt, amelynek elemeit cserélni kell.

first2
Egy előremutató iterátor, amely annak a második tartománynak az első pozíciójára mutat, amelynek elemeit cserélni kell.

Visszaadott érték

Egy előremutató iterátor, amely a második tartomány utolsó pozícióján múlt, amelynek elemeit cserélni kell.

Megjegyzések

Az összetettség lineáris az utolsó1 első1 - felcseréléssel. Ha az azonos típusú tárolók elemei felcserélhetők, akkor az swap adott tároló tagfüggvényét kell használni, mivel a tagfüggvény általában állandó összetettséggel rendelkezik.

példa

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

Egy megadott függvényobjektumot alkalmaz egy forrástartomány minden elemére vagy két forrástartomány elemeinek párjára. Ezután a függvényobjektum visszatérési értékeit egy céltartományba másolja.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first1
Egy bemeneti iterátor, amely az első forrástartomány első elemének pozícióját kezeli.

last1
Egy bemeneti iterátor, amely az első forrástartomány utolsó elemétől egy korábbi pozíciót kezel, amelyen működni szeretne.

first2
Egy bemeneti iterátor, amely a második forrástartomány első elemének pozícióját kezeli.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli.

func
Az algoritmus első verziójában használt, felhasználó által definiált nem függvényobjektum, amely az első forrástartomány minden elemére vonatkozik, vagy egy felhasználó által definiált bináris függvényobjektumra, amelyet az algoritmus második verziójában használnak, és a két forrástartományra előrefelé, egymás után alkalmazza a függvényt.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemétől egy korábbi pozíciót kezeli, amely a függvényobjektum által átalakított kimeneti elemeket fogadja.

Megjegyzések

A hivatkozott tartományoknak érvényesnek kell lenniük; az összes mutatónak késleltethetőnek kell lennie, és az egyes sorozatokon belül az utolsó pozíciónak az elsőtől a növekményesen kell elérhetőnek lennie. A céltartománynak elég nagynak kell lennie ahhoz, hogy az átalakított forrástartományt tartalmazza.

Ha az eredmény az algoritmus első verziójában egyenlő first1 , akkor a forrás- és céltartományok megegyeznek, és a sorrend módosul. result A tartományon belüli pozíciót azonban nem lehet kezelni [first1 + 1, last1).

Az összetettség lineáris. Legfeljebb (last1 - first1) összehasonlításokat végez.

példa

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

Eltávolítja azokat az ismétlődő elemeket, amelyek egy adott tartományban egymás mellett találhatók.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
Egy továbbítási iterátor, amely a vizsgálandó tartomány első elemének pozícióját kezeli duplikált eltávolítás céljából.

last
Egy továbbítási iterátor, amely a tartomány utolsó elemén túli pozíciót kezeli, és ismétlődő eltávolítást keres.

Visszaadott érték

Továbbítási iterátor a módosított sorozat új végéhez, amely nem tartalmaz egymást követő ismétlődéseket, és az utolsó elemen túli pozíciót kezeli, nem távolítva el.

Megjegyzések

Az algoritmus mindkét formája eltávolítja az egyenrangú elemek egymást követő párjának második duplikációját.

Az algoritmus működése stabil, így a nem törölt elemek relatív sorrendje nem változik.

A hivatkozott tartománynak érvényesnek kell lennie; az összes mutatónak késleltethetőnek kell lennie, és a sorrenden belül az utolsó pozíció az elsőtől a növekményesen érhető el. A sorozat elemeinek számát az algoritmus unique nem módosítja, és a módosított sorozat végén túli elemek késleltethetők, de nincsenek megadva.

Az összetettség lineáris, összehasonlítást igényel (last - first) - 1 .

A List egy hatékonyabb "egyedi" tagfüggvényt biztosít, amely jobb teljesítményt nyújthat.

Ezek az algoritmusok nem használhatók asszociatív tárolókon.

példa

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

Elemeket másol egy forrástartományból egy céltartományba, kivéve az egymás melletti ismétlődő elemeket.

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

Paraméterek

exec
A használni kívánt végrehajtási szabályzat.

first
A másolandó forrástartomány első elemének pozícióját megadó továbbítási iterátor.

last
Egy előremutató iterátor, amely a másolandó forrástartomány utolsó eleméhez tartozó pozíciót kezeli.

result
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli, és a másolat egymást követő ismétlődéseket távolít el.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemén egynél korábbi pozíciót kezel, és a másolat egymást követő ismétlődéseket távolít el.

Megjegyzések

Az algoritmus mindkét formája eltávolítja az egyenrangú elemek egymást követő párjának második duplikációját.

Az algoritmus működése stabil, így a nem törölt elemek relatív sorrendje nem változik.

A hivatkozott tartományoknak érvényesnek kell lenniük; minden mutatónak késleltethetőnek kell lennie, és egy sorozaton belül az utolsó pozíció az elsőtől a növekményesen érhető el.

Az összetettség lineáris, és (last - first) összehasonlítást igényel.

példa

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

Megkeresi egy rendezett tartomány első elemének pozícióját, amely egy megadott értéknél nagyobb értékkel rendelkezik. A bináris predikátum adja meg a rendezési feltételt.

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

Paraméterek

first
A keresendő tartomány első elemének pozíciója.

last
Az a pozíció, amely a keresendő tartomány utolsó elemét túllépi.

value
A rendezett tartomány azon értékét, amelyet meg kell haladni az iterátor által visszaadott elem értékével.

pred
A felhasználó által definiált összehasonlító predikátumfüggvény-objektum határozza meg azt az érzést, amelyben az egyik elem kisebb, mint a másik. Az összehasonlítási predikátum két argumentumot vesz fel, és akkor ad vissza true , ha elégedett, és false ha nem teljesül.

Visszaadott érték

Egy előremutató iterátor az első elem pozíciójához, amelynek értéke nagyobb, mint egy megadott érték.

Megjegyzések

A rendezett tartomány a használat upper_bound előfeltétele, és ahol a rendezési feltétel megegyezik az összehasonlítási predikátumban megadottakkal.

A tartományt a rendszer nem módosítja upper_bound.

Az algoritmus összetettsége logaritmikus a véletlenszerű hozzáférésű iterátorok és a lineáris egyéb esetekben, a lépések számával arányos (last - first).

példa

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

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-07

Megosztás a következőn keresztül:

<algorithm> függvények

adjacent_find

Paraméterek

Visszaadott érték

Megjegyzések

példa

all_of

Paraméterek

Visszaadott érték

Megjegyzések

példa

any_of

Paraméterek

Visszaadott érték

Megjegyzések

példa

binary_search

Paraméterek

Visszaadott érték

Megjegyzések

példa

clamp

Paraméterek

Visszaadott érték

Megjegyzések

copy

Paraméterek

Visszaadott érték

Megjegyzések

példa

copy_backward

Paraméterek

Visszaadott érték

Megjegyzések

példa

copy_if

Paraméterek

Visszaadott érték

Megjegyzések

példa

copy_n

Paraméterek

Visszaadott érték

Megjegyzések

példa

count

Paraméterek

Visszaadott érték

Megjegyzések

példa

count_if

Paraméterek

Visszaadott érték

Megjegyzések

példa

equal

Paraméterek

Visszaadott érték

Megjegyzések

példa

equal_range

Paraméterek

Visszaadott érték

Megjegyzések

példa

fill

Paraméterek

Megjegyzések

példa

fill_n

Paraméterek

Visszaadott érték

Megjegyzések

példa

find

Paraméterek

Visszaadott érték

Megjegyzések

find_end

`<algorithm>` függvények

`adjacent_find`

`all_of`

`any_of`

`binary_search`

`clamp`

`copy`

`copy_backward`

`copy_if`

`copy_n`

`count`

`count_if`

`equal`

`equal_range`

`fill`

`fill_n`

`find`

`find_end`

`find_first_of`

`find_if`

`find_if_not`

`for_each`

`for_each_n`

`generate`

`generate_n`

`includes`

`inplace_merge`

`is_permutation`

`is_sorted`

`is_sorted_until`