<algorithm>

Definisce le funzioni di modelli standard del contenitore di (STL) la libreria di modelli che eseguono algoritmi.

namespace std {
template<class InputIterator, class Predicate>
    bool all_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool any_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool none_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Function>
    Fn1 for_each (
        InputIterator _First, 
        InputIterator _Last, 
        Function _Func
    );
template<class InputIterator, class Type>
    InputIterator find (
        InputIterator _First, 
        InputIterator _Last, 
        const Type& _Val
    );
template<class InputIterator, class Predicate>
    InputIterator find_if (
        InputIterator _First, 
        InputIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    InputIterator find_if_not (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    ); 
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class InputIterator, class ForwardIterator>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2
    );
template<class InputIterator, class ForwardIterator, 
         class Predicate>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last
    );
template<class ForwardIterator, class Predicate>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Type>
    typename iterator_traits<InputIterator>::difference_type
        count (
            InputIterator _First, 
            InputIterator _Last,
            const Type& _Val
        );
template<class InputIterator, class Predicate>
    typename iterator_traits<InputIterator>::difference_type
        count_if (
            InputIterator _First, 
            InputIterator _Last,
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2
        );
template<class InputIterator1, class InputIterator2, class Predicate>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2, 
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2
    );
template<class InputIterator1, class InputIterator2, class Predicate>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2, 
        Predicate _Pred
    );
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator, class Size, class Type>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val
    );
template<class ForwardIterator, class Size, class Type, 
         class Predicate>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val, 
        Predicate _Pred
    );

Note

Gli algoritmi STL sono generici perché possono operare diverse strutture dei dati.Le strutture di dati che possono operare non includono solo le classi di contenitori STL come vector e list, ma anche le strutture di dati e matrici di programmi specifici di elementi che soddisfano le esigenze di un algoritmo specifico.Gli algoritmi STL raggiunto il livello di accesso generale e attraversa gli elementi di un contenitore indirettamente con gli iteratori.

Gli algoritmi STL elaborano gli intervalli dell'iteratore che in genere vengono specificati dall'inizio o percorsi finali.Gli intervalli definiti siano validi nel senso che tutti i puntatori in intervalli devono essere dereferenceable e, nelle sequenze di ogni intervallo, l'ultima posizione sia raggiungibile da prima dall'aumento.

Gli algoritmi STL estendono le azioni supportate dai meccanismi e dalle funzioni membro di ogni contenitore STL e consentono l'esecuzione, ad esempio, con diversi tipi di oggetti contenitore contemporaneamente.Due suffissi sono stati utilizzati per trasferire le informazioni sullo scopo di algoritmo.

• Se il suffisso indica che l'algoritmo utilizzato con gli oggetti funzione che agiscono sui valori degli elementi anziché sui valori degli elementi stessi.L'algoritmo find_if cerca gli elementi i cui valori soddisfano i criteri specificati da un oggetto funzione e l'algoritmo find cerca un valore specifico.

• Il suffisso _copy indica che l'algoritmo non solo modifica i valori degli elementi anche copiare i valori modificati in un intervallo di destinazione.L'algoritmo reverse inverte l'ordine degli elementi di un intervallo e l'algoritmo reverse_copy anche copia il risultato in un intervallo di destinazione.

Gli algoritmi STL vengono classificati spesso in gruppi che indicano un elemento sullo scopo o requisiti.Questi includono modificare gli algoritmi che modificano il valore di elementi rispetto a quelli nonmodifying che non fanno.Gli algoritmi subenti una modifica modificare l'ordine degli elementi, ma non i valori dei relativi elementi.Rimuovere gli algoritmi può rimuovere elementi da un intervallo o da una copia di un intervallo.Gli algoritmi di ordinamento riordinano gli elementi in un intervallo in diversi modi e gli algoritmi ordinatiintervallo funzionano solo sugli algoritmi dei cui elementi sono stati ordinati in modo specifico.

Gli DERIVA che gli algoritmi numerici disponibili per l'elaborazione numerica dispongono di un proprio file di intestazione <numeric>e oggetti funzione e adattatori sono definiti negli oggetti funzione <functional> di intestazione che i valori booleani di ritorno sono noti come predicati.Il predicato binario predefinito è il confronto operator<.In genere gli elementi che sono necessarie ordinata di essere minore di confrontabile in modo che, specificando tutti gli due elementi, poter stabilire uno che siano equivalenti in quanto non è inferiore all'altro) o che ne è inferiore all'altro.Ciò comporta un ordine tra elementi antivalenti.

Funzioni

adjacent_find	Cerca due elementi adiacenti che sono uguali o soddisfano una condizione specificata.
all_of	Restituisce true quando una condizione è presente in ogni elemento nell'intervallo specificato.
any_of	Restituisce true quando una condizione è almeno una volta presente nell'intervallo specificato di elementi.
binary_search	Verifica se è presente un elemento in un intervallo ordinato equivalente a un valore specificato o che equivale a in un certo senso specificato da un predicato binario.
copy	L'assegnazione dei valori degli elementi da un intervallo di origine in un intervallo di destinazione, ripetenti con la sequenza di origine di elementi e assegnare loro le nuove posizioni in avanti.
copy_backward	L'assegnazione dei valori degli elementi da un intervallo di origine in un intervallo di destinazione, ripetenti con la sequenza di origine di elementi e assegnare loro le nuove posizioni indietro in una direzione.
copy_if	Copiare tutti gli elementi in un intervallo specificato che testano true per una specifica
copy_n	Copia un numero specificato di elementi.
Conteggio	Restituisce il numero di elementi in un intervallo dei valori corrispondono a un valore specificato.
count_if	Restituisce il numero di elementi in un intervallo dei valori corrispondono a una condizione specificata.
EQUAL	Confronta un elemento di due intervalli dall'elemento per uguaglianza o equivalenza in un certo senso specificato da un predicato binario.
equal_range	Cerca una coppia di posizioni in un intervallo ordinato, nel primo minore di o nell'equivalente alla posizione di un elemento specificato e il secondo maggiore di quella dell'elemento, dove il concetto di equivalenza o dell'ordine utilizzato per definire le posizioni in sequenza può essere specificato da un predicato binario.
fill	Assegna lo stesso nuovo valore a ogni elemento in un intervallo specificato.
fill_n	Assegna un valore a un numero specificato di elementi in un intervallo che inizia con un determinato elemento.
find	Individuare la posizione della prima occorrenza di un elemento in un intervallo con un valore specificato.
find_end	Ricerca in un intervallo per l'ultima sottosequenza identica a una sequenza specificata o che equivale in un certo senso specificato da un predicato binario.
find_first_of	Ricerca della prima occorrenza dei singoli valori in un intervallo di destinazione riferimento o della prima occorrenza di uno dei vari elementi che sono equivalenti in un certo senso specificati da un predicato binario in un set specificato di elementi.
find_if	Individuare la posizione della prima occorrenza di un elemento in un intervallo che soddisfa una condizione specificata.
find_if_not	Restituisce il primo elemento nell'intervallo indicato che non soddisfa una condizione.
for_each	Applica un oggetto funzione specificata a ogni elemento di un ordine avanti in un intervallo e restituisce l'oggetto funzione.
generare	L'assegnazione dei valori generati da un oggetto funzione a ogni elemento in un intervallo.
generate_n	L'assegnazione dei valori generati da un oggetto funzione a un numero specificato di elementi è un intervallo e restituisce la posizione una dopo l'ultimo valore assegnato.
importa	Verifica se un intervallo ordinato contiene tutti gli elementi contenuti in un secondo intervallo ordinato, in cui il modello di equivalenza l'ordinamento o tra elementi può essere specificato da un predicato binario.
inplace_merge	Combina elementi da due intervalli ordinati consecutivi in un unico intervallo ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.
is_heap	Restituisce true se gli elementi nell'intervallo specificato da un heap.
is_heap_until	Restituisce true se l'intervallo specificato forma un heap fino all'ultimo elemento.
is_partitioned	Restituisce true se tutti gli elementi dell'intervallo specificato che testano true a una condizione non prima di tutti gli elementi che testano false.
is_sorted	Restituisce true se gli elementi nell'intervallo specificato vengono ordinati.
is_sorted_until	Restituisce true se gli elementi nell'intervallo specificato vengono ordinati.
iter_swap	Gli scambi due valori sono segnalati da una coppia degli iteratori specificati.
lexicographical_compare	Confronta dell'elemento tra due sequenze per determinare quale è minore dei due.
lower_bound	Cerca la posizione del primo elemento in un intervallo ordinato con un valore maggiore di o equivalente a un valore specificato, dove il criterio di ordinamento può essere specificato da un predicato binario.
make_checked_array_iterator	Crea checked_array_iterator utilizzabile da altri algoritmi.
make_heap	Converte gli elementi da un intervallo specificato in un heap in cui il primo elemento è il più grande e per il quale una chiave di ordinamento può essere specificata con un predicato binario.
max	Confronta due oggetti e restituisce il maggiore di due, dove il criterio di ordinamento può essere specificato da un predicato binario.
max_element	Cercare la prima occorrenza di elemento più grande in un intervallo specificato in cui il criterio di ordinamento può essere specificato da un predicato binario.
unione	Combina tutti gli elementi da due stato ordinato gli intervalli di origine in un singolo, l'intervallo di destinazione ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.
min	Confronta due oggetti e restituisce il minore dei due, dove il criterio di ordinamento può essere specificato da un predicato binario.
min_element	Cercare la prima occorrenza di più piccolo elemento in un intervallo specificato in cui il criterio di ordinamento può essere specificato da un predicato binario.
minmax	Confronta due parametri di input e li restituisce come coppia, per minimo a più grande.
minmax_element	Esegue il lavoro eseguito da min_element e da max_element in una chiamata a.
mancata corrispondenza	Confronta un elemento di due intervalli dall'elemento per uguaglianza o l'equivalente in un certo senso specificato da un predicato binario e individuare la prima posizione in cui una differenza si verifica.
<alg> move	Elementi di spostamento associati a un intervallo specificato.
move_backward	Consente di spostare gli elementi di un iteratore a un altro.L'avvio di spostamento all'ultimo elemento in un intervallo specificato e terminano con il primo elemento in tale intervallo.
next_permutation	Riordina gli elementi in un intervallo in modo che l'ordine originale viene sostituita dalla maggior permutazione lessicografico seguente se esiste, nel caso del successivo può essere specificato con un predicato binario.
none_of	Restituisce true quando una condizione non viene mai disponibile tra gli elementi dell'intervallo specificato.
nth_element	Partiziona un intervallo di elementi, correttamente posizionamento l'ennesimo elemento della sequenza nell'intervallo in modo che tutti gli elementi iniziale sia minore o uguale a e tutti gli elementi che lo seguono la sequenza è maggiore o uguale a.
partial_sort	Dispone di un numero specificato di elementi più piccoli in un intervallo in un ordine nondescending o come un criterio di ordinamento specificato da un predicato binario.
partial_sort_copy	Copia di elementi da un intervallo di origine in un intervallo di destinazione in cui gli elementi di origine ordinate e minore o da un altro file binario predicato specificato.
partizione	Le classi degli elementi in un intervallo in due disgiunte set, con gli elementi che soddisfano il predicato unario che precede quelli che non vengono soddisfarlo.
partition_copy	Gli elementi di copie per il quale una condizione è true a una destinazione e per cui la condizione viene false a un altro.Gli elementi devono provenire da un intervallo specificato.
partition_point	Restituisce il primo elemento nell'intervallo specificato che non soddisfa la condizione.Gli elementi vengono ordinati in modo che quelli che soddisfano la condizione si verifica prima di quelli che non fanno.
pop_heap	Elimina il massimo elemento dall'inizio di un heap al successivo (- ultima posizione nell'intervallo e quindi costituisce una nuova heap gli elementi rimanenti.
prev_permutation	Riordina gli elementi in un intervallo in modo che l'ordine originale viene sostituita dalla maggior permutazione lessicografico seguente se esiste, nel caso del successivo può essere specificato con un predicato binario.
push_heap	Aggiunge un elemento che si trova alla fine di un intervallo a un heap esistente che include gli elementi precedenti nell'intervallo.
random_shuffle	Ridisporre una sequenza di elementi N in un intervallo in una di N!disposizioni possibili selezionate casualmente.
remove	Rimuove un valore specificato da un intervallo specificato senza pregiudicare l'ordine degli elementi rimanenti e restituire la fine del nuovo intervallo esente dal valore specificato.
remove_copy	Copia di elementi da un intervallo di origine in un intervallo di destinazione, ad eccezione degli elementi di un determinato valore non vengono copiati, senza pregiudicare l'ordine degli elementi rimanenti e restituire la fine del nuovo intervallo di destinazione.
remove_copy_if	Copia di elementi da un intervallo di origine in un intervallo di destinazione, ma la presenza di un predicato non vengono copiati, senza pregiudicare l'ordine degli elementi rimanenti e restituire la fine del nuovo intervallo di destinazione.
remove_if	Rimuove gli elementi che soddisfano il predicato con un intervallo specificato senza pregiudicare l'ordine degli elementi rimanenti e restituire la fine del nuovo intervallo esente dal valore specificato.
replace	Esamina ogni elemento in un intervallo e lo sostituirà se corrisponde a un valore specificato.
replace_copy	Esamina ogni elemento in un intervallo di origine e lo sostituirà se corrisponde a un valore specificato come copia il risultato in un nuovo intervallo di destinazione.
replace_copy_if	Esamina ogni elemento in un intervallo di origine e lo sostituirà se soddisfano il predicato specificato come copia il risultato in un nuovo intervallo di destinazione.
replace_if	Esamina ogni elemento in un intervallo e lo sostituirà se soddisfano il predicato specificato.
inverso	Inverte l'ordine degli elementi in un intervallo.
reverse_copy	Inverte l'ordine degli elementi di un intervallo di origine e copiarli in un intervallo di destinazione
ruotare	Scambia gli elementi in due intervalli adiacenti.
rotate_copy	Scambia gli elementi in due intervalli adiacenti in un intervallo di origine e copia il risultato in un intervallo di destinazione.
cercare	Cercare la prima occorrenza di una sequenza in un intervallo di destinazione riferimento ai cui elementi sono uguali a quelli della sequenza specificata di elementi oppure dei cui elementi sono equivalenti in un certo senso specificati da un predicato binario agli elementi nella sequenza specificata.
search_n	Cercare la prima sottosequenza in un intervallo di un numero specificato di elementi che dispongono di un valore specifico o una relazione in tale valore come specificato da un predicato binario.
set_difference	Unisce tutti gli elementi appartenenti a un intervallo di origine ordinato, ma non a un altro stato ordinato l'intervallo di origine, in un unico, l'intervallo di destinazione ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.
set_intersection	Unisce tutti gli elementi appartenenti a entrambi sono ordinati gli intervalli di origine in un singolo, l'intervallo di destinazione ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.
set_symmetric_difference	Unisce tutti gli elementi appartenenti a uno, ma non entrambi, gli intervalli di origine ordinati in un singolo, è ordinato l'intervallo di destinazione, in cui il criterio di ordinamento può essere specificato da un predicato binario.
set_union	Unisce tutti gli elementi appartenenti ad almeno uno di due hanno ordinato gli intervalli di origine in un singolo, l'intervallo di destinazione ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.
sort	Dispone gli elementi in un intervallo specificato in un ordine nondescending o come un criterio di ordinamento specificato da un predicato binario.
sort_heap	Converte un heap in un intervallo ordinato.
stable_partition	Le classi degli elementi in un intervallo in due disgiunte set, con gli elementi che soddisfano il predicato unario che precede quelli che non vengono soddisfarlo, conservare l'ordine degli elementi equivalenti.
stable_sort	Dispone gli elementi in un intervallo specificato in un ordine nondescending o come un criterio di ordinamento specificato da un predicato binario e conserva l'ordine degli elementi equivalenti.
scambio	Scambia i valori degli elementi tra due tipi di oggetti, assegnare contenuto del primo oggetto dal secondo oggetto e il contenuto del secondo al primo.
swap_ranges	Scambia gli elementi di un intervallo con gli elementi di un altro, intervallo di dimensioni di uguale.
trasformazione	Applica un oggetto funzione specificata a ogni elemento in un intervallo di origine o a una coppia di elementi da due intervalli di origine e copia i valori restituiti dell'oggetto funzione in un intervallo di destinazione.
univoco	Elimina elementi duplicati che sono adiacenti all'altro in un intervallo specificato.
unique_copy	Copia di elementi da un intervallo di origine in un intervallo di destinazione eccezione degli elementi duplicati che sono adiacenti all'altro.
upper_bound	Cerca la posizione del primo elemento in un intervallo ordinato con un valore maggiore di un valore specificato, dove il criterio di ordinamento può essere specificato da un predicato binario.

Vedere anche

Riferimenti

Thread safety della libreria C++ standard

Libreria di modelli standard

Altre risorse

File di intestazione