std::partition - cppreference.com

Da cppreference.com.

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Elemento definito nell'header `<algorithm>`

`template< class BidirIt, class UnaryPredicate > BidirectionalIterator partition( BidirIt first, BidirIt last, UnaryPredicate p ); template< class ForwardIt, class UnaryPredicate > ForwardIt partition( ForwardIt first, ForwardIt last, UnaryPredicate p );`		(fino al c++11) (dal C++11)

Riordina gli elementi nel [first, last) gamma in modo tale che tutti gli elementi per cui il predicato p rendimenti true precedere gli elementi per i quali predicato p rendimenti false. Ordine relativo degli elementi non è conservato.

Original:

Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is not preserved.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parametri

first, last	-	la gamma di elementi da riordinare Original: the range of elements to reorder The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
p	-	unary predicate which returns `true` se l'elemento deve essere ordinato prima di altri elementi Original: if the element should be ordered before other elements The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. . The signature of the predicate function should be equivalent to the following: `bool pred(const Type &a);` The signature does not need to have `const &`, but the function must not modify the objects passed to it. The type `Type` must be such that an object of type `ForwardIt` can be dereferenced and then implicitly converted to `Type`.
Type requirements
-`BidirIt` must meet the requirements of `BidirectionalIterator`.
-`ForwardIt` must meet the requirements of `ValueSwappable` and `ForwardIterator`. However, the operation is more efficient if `ForwardIt` also satisfies the requirements of `BidirectionalIterator`

Valore di ritorno

Iteratore al primo elemento del secondo gruppo.

Original:

Iterator to the first element of the second group.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Complessità

Esattamente last-first applicazioni del predicato e la maggior parte delle operazioni di swap last-first. Se ForwardIt soddisfa i requisiti della maggior parte delle operazioni di swap in BidirectionalIterator (last-first)/2 sono fatte.

Original:

Exactly last-first applications of the predicate and at most last-first swaps. If ForwardIt meets the requirements of BidirectionalIterator at most (last-first)/2 swaps are done.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Possibile implementazione

template<class BidirIt, class UnaryPredicate>
BidirIt partition(BidirIt first, BidirIt last, UnaryPredicate p)
{
    while (1) {
        while ((first != last) && p(*first)) {
            ++first;
        }
        if (first == last--) break;
        while ((first != last) && !p(*last)) {
            --last;
        }
        if (first == last) break;
        std::swap(*first++, *last);
    }
    return first;
}

Esempio

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>

bool is_even(int i) { return i % 2 == 0; }

int main()
{
    std::vector<int> v;
    for (int i = 0; i < 10; ++i) v.push_back(i);
    
    std::cout << "Original vector:\n    ";
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    
    // Partition the vector
    std::vector<int>::iterator p =
        std::partition(v.begin(), v.end(), std::ptr_fun(is_even));
    
    std::cout << "\nPartitioned vector:\n    ";
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\nBefore partition:\n    ";
    std::copy(v.begin(), p,       std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\nAfter partition:\n    ";
    std::copy(p,         v.end(), std::ostream_iterator<int>(std::cout, " "));
}

Possible output:

Original vector:
    0 1 2 3 4 5 6 7 8 9 
Partitioned vector:
    0 8 2 6 4 5 3 7 1 9 
Before partition:
    0 8 2 6 4 
After partition:
    5 3 7 1 9

Vedi anche


	determina se il campo è diviso dal predicato specificato Original: determines if the range is partitioned by the given predicate The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]

	divide gli elementi in due gruppi, mantenendo l'ordine relativo Original: divides elements into two groups while preserving their relative order The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]