algorithm (STL/CLR)

Definisce i modelli di funzione contenitore STL/CLR che eseguono algoritmi.

Sintassi

#include <cliext/algorithm>

Requisiti

Header:<cliext/algorithm>

Spazio dei nomi: cliext

Dichiarazioni

Funzione	Descrizione
adjacent_find (STL/CLR)	Cerca due elementi adiacenti uguali.
binary_search (STL/CLR)	Verifica se una sequenza ordinata contiene un valore specificato.
copy (STL/CLR)	Copia i valori da un intervallo di origine a un intervallo di destinazione, iterando nella direzione in avanti.
copy_backward (STL/CLR)	Copia i valori da un intervallo di origine a un intervallo di destinazione, iterando nella direzione indietro.
count (STL/CLR)	Restituisce il numero di elementi di un intervallo i cui valori corrispondono a un valore specificato.
count_if (STL/CLR)	Restituisce il numero di elementi di un intervallo i cui valori corrispondono a una condizione specificata.
equal (STL/CLR)	Confronta due intervalli, elemento per elemento.
equal_range (STL/CLR)	Cerca una sequenza ordinata di valori e restituisce due posizioni che delimitano una sottosequenza di valori tutti uguali a un determinato elemento.
fill (STL/CLR)	Assegna lo stesso nuovo valore a ogni elemento di un intervallo specificato.
fill_n (STL/CLR)	Assegna un nuovo valore a un numero specificato di elementi di un intervallo che inizia con un determinato elemento.
find (STL/CLR)	Restituisce la posizione della prima occorrenza di un valore specificato.
find_end (STL/CLR)	Restituisce l'ultima sottosequenza in un intervallo identico a una sequenza specificata.
find_first_of (STL/CLR)	Cerca in un intervallo la prima occorrenza di uno qualsiasi di un determinato intervallo di elementi.
find_if (STL/CLR)	Restituisce la posizione del primo elemento in una sequenza di valori in cui l'elemento soddisfa una condizione specificata.
for_each (STL/CLR)	Applica un oggetto funzione specificato a ogni elemento in una sequenza di valori e restituisce l'oggetto funzione.
generate (STL/CLR)	Assegna i valori generati da un oggetto funzione a ogni elemento in una sequenza di valori.
generate_n (STL/CLR)	Assegna i valori generati da un oggetto funzione a un numero specificato di elementi.
includes (STL/CLR)	Verifica se un intervallo ordinato contiene tutti gli elementi di un secondo intervallo ordinato.
inplace_merge (STL/CLR)	Combina gli elementi di due intervalli ordinati consecutivi in un singolo intervallo ordinato.
iter_swap (STL/CLR)	Scambia due valori a cui viene fatto riferimento da una coppia di iteratori specificati.
lexicographical_compare (STL/CLR)	Confronta due sequenze, elemento per elemento, che identifica la sequenza minore dei due.
lower_bound (STL/CLR)	Trova la posizione del primo elemento in una sequenza ordinata di valori con un valore maggiore o uguale a un valore specificato.
make_heap (STL/CLR)	Converte gli elementi da un intervallo specificato in un heap in cui il primo elemento nell'heap è il più grande.
max (STL/CLR))	Confronta due oggetti e restituisce il valore maggiore dei due.
max_element (STL/CLR)	Trova l'elemento più grande in una sequenza di valori specificata.
merge (STL/CLR))	Combina tutti gli elementi di due intervalli di origine ordinati in un singolo intervallo di destinazione ordinato.
min (STL/CLR)	Confronta due oggetti e restituisce il minore dei due.
min_element (STL/CLR)	Trova l'elemento più piccolo in una sequenza di valori specificata.
mismatch (STL/CLR)	Confronta due intervalli per elemento e restituisce la prima posizione in cui si verifica una differenza.
next_permutation (STL/CLR)	Riordina gli elementi in un intervallo in modo che l'ordinamento originale venga sostituito dalla successiva permutazione maggiore lessicografica, se presente.
nth_element (STL/CLR)	Partiziona una sequenza di elementi, individuando correttamente l'elemento nth della sequenza in modo che tutti gli elementi di fronte siano minori o uguali a esso e tutti gli elementi che lo seguono sono maggiori o uguali.
partial_sort (STL/CLR)	Dispone un numero specificato di elementi più piccoli in un intervallo in ordine non decrescente.
partial_sort_copy (STL/CLR)	Copia gli elementi da un intervallo di origine in un intervallo di destinazione in modo che gli elementi dell'intervallo di origine siano ordinati.
partition (STL/CLR)	Dispone gli elementi in un intervallo in modo che gli elementi che soddisfano un predicato unario precedono quelli che non lo soddisfano.
pop_heap (STL/CLR)	Sposta l'elemento più grande dalla parte anteriore di un heap alla fine e quindi forma un nuovo heap dagli elementi rimanenti.
prev_permutation (STL/CLR)	Riordina una sequenza di elementi in modo che l'ordinamento originale venga sostituito dalla permutazione precedente lessicografica precedente, se presente.
push_heap (STL/CLR)	Aggiunge un elemento che si trova alla fine di un intervallo a un heap esistente costituito dagli elementi precedenti dell'intervallo.
random_shuffle (STL/CLR)	Riorganizzare una sequenza di N elementi in un intervallo in uno di N. possibili disposizioni selezionate in modo casuale.
remove (STL/CLR)	Elimina un valore specificato da un determinato intervallo senza disturbare l'ordine degli elementi rimanenti e restituisce la fine di un nuovo intervallo libero del valore specificato.
remove_copy (STL/CLR)	Copia gli elementi da un intervallo di origine a un intervallo di destinazione, ad eccezione del fatto che gli elementi di un valore specificato non vengono copiati, senza disturbare l'ordine degli elementi rimanenti.
remove_copy_if (STL/CLR)	Copia gli elementi da un intervallo di origine a un intervallo di destinazione, ad eccezione di quelli che soddisfano un predicato, senza disturbare l'ordine degli elementi rimanenti.
remove_if (STL/CLR)	Elimina gli elementi che soddisfano un predicato da un determinato intervallo senza disturbare l'ordine degli elementi rimanenti. .
replace (STL/CLR)	Sostituisce gli elementi in un intervallo che corrispondono a un valore specificato con un nuovo valore.
replace_copy (STL/CLR)	Copia gli elementi da un intervallo di origine a un intervallo di destinazione, sostituendo gli elementi che corrispondono a un valore specificato con un nuovo valore.
replace_copy_if (STL/CLR)	Esamina ogni elemento di un intervallo di origine e lo sostituisce se soddisfa un predicato specificato copiando nel contempo il risultato in un nuovo intervallo di destinazione.
replace_if (STL/CLR)	Esamina ogni elemento di un intervallo e lo sostituisce se soddisfa un predicato specificato.
reverse (STL/CLR)	Inverte l'ordine degli elementi all'interno di un intervallo.
reverse_copy (STL/CLR)	Inverte l'ordine degli elementi all'interno di un intervallo di origine durante la copia in un intervallo di destinazione.
rotate (STL/CLR)	Scambia gli elementi di due intervalli adiacenti.
rotate_copy (STL/CLR)	Scambia gli elementi di due intervalli adiacenti all'interno di un intervallo di origine e copia il risultato in un intervallo di destinazione.
search (STL/CLR)	Cerca la prima occorrenza di una sequenza all'interno di un intervallo di destinazione i cui elementi sono uguali a quelli di una sequenza specificata di elementi oppure i cui elementi sono equivalenti nel senso specificato da un predicato binario agli elementi della sequenza specificata.
search_n (STL/CLR)	Cerca la prima sottosequenza di un intervallo di un numero specificato di elementi che dispongono di un valore specifico o di una relazione con tale valore come specificato da un predicato binario.
set_difference (STL/CLR)	Unisce tutti gli elementi appartenenti a un intervallo di origine ordinato, ma non a un secondo intervallo di origine ordinato, in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.
set_intersection (STL/CLR)	Unisce tutti gli elementi appartenenti a entrambi gli intervalli di origine ordinati in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.
set_symmetric_difference (STL/CLR)	Unisce tutti gli elementi appartenenti a uno degli intervalli di origine ordinati, ma non ad entrambi, in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.
set_union (STL/CLR))	Unisce tutti gli elementi appartenenti almeno a uno dei due intervalli di origine ordinati in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.
sort (STL/CLR)	Dispone gli elementi di un intervallo specificato in un ordine non decrescente o secondo un criterio di ordinamento specificato da un predicato binario.
sort_heap (STL/CLR)	Converte un heap in un intervallo ordinato.
stable_partition (STL/CLR)	Classifica gli elementi di un intervallo in due set non contigui, con gli elementi che soddisfano un predicato unario che precedono quelli che non lo soddisfano, mantenendo l'ordine relativo degli elementi equivalenti.
stable_sort (STL/CLR)	Dispone gli elementi di un intervallo specificato in un ordine non decrescente o secondo un criterio di ordinamento specificato da un predicato binario e mantiene l'ordinamento relativo degli elementi equivalenti.
swap (STL/CLR)	Scambia i valori degli elementi tra due tipi di oggetti, assegnando il contenuto del primo oggetto al secondo oggetto e il contenuto del secondo al primo.
swap_ranges (STL/CLR)	Scambia gli elementi di un intervallo con gli elementi di un altro intervallo di uguali dimensioni.
transform (STL/CLR)	Applica un oggetto funzione ad ogni elemento di un intervallo di origine o a una coppia di elementi di due intervalli di origine e copia i valori restituiti dell'oggetto funzione in un intervallo di destinazione.
unique (STL/CLR)	Rimuove gli elementi duplicati adiacenti l'uno rispetto all'altro in un intervallo specificato.
unique_copy (STL/CLR)	Copia gli elementi di un intervallo di origine in un intervallo di destinazione ad eccezione degli elementi duplicati adiacenti l'uno rispetto all'altro.
upper_bound (STL/CLR)	Trova la posizione del primo elemento in un intervallo ordinato con un valore maggiore di un valore specificato, in cui il criterio di ordinamento può essere specificato da un predicato binario.

Membri

adjacent_find (STL/CLR)

Cerca due elementi adiacenti uguali o che soddisfano una condizione specificata.

Sintassi

template<class _FwdIt> inline
    _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria adjacent_findstandard C++. Per altre informazioni, vedere adjacent_find.

binary_search (STL/CLR)

Verifica se in un intervallo ordinato è presente un elemento uguale a un valore specificato o equivalente a tale valore nel senso specificato da un predicato binario.

Sintassi

template<class _FwdIt, class _Ty> inline
    bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    bool binary_search(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria binary_searchstandard C++. Per altre informazioni, vedere binary_search.

copy (STL/CLR)

Assegna i valori degli elementi di un intervallo di origine a un intervallo di destinazione, scorrendo la sequenza di origine degli elementi e assegnando loro nuove posizioni in avanti.

Sintassi

template<class _InIt, class _OutIt> inline
    _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest);

Osservazioni:

Questa funzione si comporta come la funzione della libreria copystandard C++. Per altre informazioni, vedere copy.

copy_backward (STL/CLR)

Assegna i valori degli elementi di un intervallo di origine a un intervallo di destinazione, scorrendo la sequenza di origine degli elementi e assegnando loro nuove posizioni in indietro.

Sintassi

template<class _BidIt1, class _BidIt2> inline
    _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last,
        _BidIt2 _Dest);

Osservazioni:

Questa funzione si comporta come la funzione della libreria copy_backwardstandard C++. Per altre informazioni, vedere copy_backward.

count (STL/CLR)

Restituisce il numero di elementi di un intervallo i cui valori corrispondono a un valore specificato.

Sintassi

template<class _InIt, class _Ty> inline
    typename iterator_traits<_InIt>::difference_type
        count(_InIt _First, _InIt _Last, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria countstandard C++. Per altre informazioni, vedere Count.

count_if (STL/CLR)

Restituisce il numero di elementi di un intervallo i cui valori corrispondono a una condizione specificata.

Sintassi

template<class _InIt, class _Pr> inline
    typename iterator_traits<_InIt>::difference_type
        count_if(_InIt _First, _InIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria count_ifstandard C++. Per altre informazioni, vedere count_if.

equal (STL/CLR)

Confronta due intervalli elemento per elemento per verificarne l'uguaglianza o l'equivalenza nel senso specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2> inline
    bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2);
template<class _InIt1, class _InIt2, class _Pr> inline
    bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
        _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria equalstandard C++. Per altre informazioni, vedere uguale.

equal_range (STL/CLR)

Trova una coppia di posizioni in un intervallo ordinato, la prima inferiore o equivalente alla posizione di un elemento specificato e la seconda maggiore della posizione di tale elemento, in cui il senso dell'equivalenza o dell'ordinamento usato per stabilire le posizioni nella sequenza può essere specificato da un predicato binario.

Sintassi

template<class _FwdIt, class _Ty> inline
    _PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    _PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria equal_rangestandard C++. Per altre informazioni, vedere equal_range.

fill (STL/CLR)

Assegna lo stesso nuovo valore a ogni elemento di un intervallo specificato.

Sintassi

template<class _FwdIt, class _Ty> inline
    void fill(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria fillstandard C++. Per altre informazioni, vedere Riempimento.

fill_n (STL/CLR)

Assegna un nuovo valore a un numero specificato di elementi di un intervallo che inizia con un determinato elemento.

Sintassi

template<class _OutIt, class _Diff, class _Ty> inline
    void fill_n(_OutIt _First, _Diff _Count, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria fill_nstandard C++. Per altre informazioni, vedere fill_n.

find (STL/CLR)

Individua la posizione della prima occorrenza di un elemento in un intervallo con un valore specificato.

Sintassi

template<class _InIt, class _Ty> inline
    _InIt find(_InIt _First, _InIt _Last, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria findstandard C++. Per altre informazioni, vedere Trovare.

find_end (STL/CLR)

Ricerca in un intervallo l'ultima sottosequenza identica a una sequenza specificata o equivalente nel senso specificato da un predicato binario.

Sintassi

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
    _FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria find_endstandard C++. Per altre informazioni, vedere find_end.

find_first_of (STL/CLR)

Ricerca la prima occorrenza di uno dei diversi valori all'interno di un intervallo di destinazione o la prima occorrenza di uno dei diversi elementi equivalenti nel senso specificato da un predicato binario in un set specificato di elementi.

Sintassi

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
    _FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria find_first_ofstandard C++. Per altre informazioni, vedere find_first_of.

find_if (STL/CLR)

Individua la posizione della prima occorrenza di un elemento in un intervallo che soddisfa una condizione specificata.

Sintassi

template<class _InIt, class _Pr> inline
    _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria find_ifstandard C++. Per altre informazioni, vedere find_if.

for_each (STL/CLR)

Applica un oggetto funzione specificato a ogni elemento ordinato in avanti all'interno di un intervallo e restituisce l'oggetto funzione.

Sintassi

template<class _InIt, class _Fn1> inline
    _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func);

Osservazioni:

Questa funzione si comporta come la funzione della libreria for_eachstandard C++. Per altre informazioni, vedere for_each.

generate (STL/CLR)

Assegna i valori generati da un oggetto funzione a ogni elemento di un intervallo.

Sintassi

template<class _FwdIt, class _Fn0> inline
    void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func);

Osservazioni:

Questa funzione si comporta come la funzione della libreria generatestandard C++. Per altre informazioni, vedere Generate.

generate_n (STL/CLR)

Assegna i valori generati da un oggetto funzione a un numero specificato di elementi di un intervallo e torna alla posizione immediatamente successiva all'ultimo valore assegnato.

Sintassi

template<class _OutIt, class _Diff, class _Fn0> inline
    void generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func);

Osservazioni:

Questa funzione si comporta come la funzione della libreria generate_nstandard C++. Per altre informazioni, vedere generate_n.

includes (STL/CLR)

Verifica se un intervallo ordinato contiene tutti gli elementi contenuti in un secondo intervallo ordinato, in cui il criterio di ordinamento o di equivalenza tra gli elementi può essere specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2> inline
    bool includes(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2);
template<class _InIt1, class _InIt2, class _Pr> inline
    bool includes(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria includesstandard C++. Per altre informazioni, vedere Include.

inplace_merge (STL/CLR)

Combina gli elementi di due intervalli ordinati consecutivi in un unico intervallo ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _BidIt> inline
    void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last,
        _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria inplace_merge standard C++. Per altre informazioni, vedere inplace_merge.

iter_swap (STL/CLR)

Scambia due valori a cui viene fatto riferimento da una coppia di iteratori specificati.

Sintassi

template<class _FwdIt1, class _FwdIt2> inline
    void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right);

Osservazioni:

Questa funzione si comporta come la funzione della libreria iter_swapstandard C++. Per altre informazioni, vedere iter_swap.

lexicographical_compare (STL/CLR)

Confronta due sequenze elemento per elemento per determinare quale delle due è minore.

Sintassi

template<class _InIt1, class _InIt2> inline
    bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2);
template<class _InIt1, class _InIt2, class _Pr> inline
    bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria lexicographical_comparestandard C++. Per altre informazioni, vedere lexicographical_compare.

lower_bound (STL/CLR)

Trova la posizione del primo elemento in un intervallo ordinato con un valore minore o equivalente a un valore specificato, in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _FwdIt, class _Ty> inline
    _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria lower_boundstandard C++. Per altre informazioni, vedere lower_bound.

make_heap (STL/CLR)

Converte gli elementi di un intervallo specificato in un heap in cui il primo elemento è il più grande e per il quale un criterio di ordinamento può essere specificato con un predicato binario.

Sintassi

template<class _RanIt> inline
    void make_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria make_heapstandard C++. Per altre informazioni, vedere make_heap.

max (STL/CLR)

Confronta due oggetti e restituisce il maggiore dei due in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _Ty> inline
    const _Ty max(const _Ty% _Left, const _Ty% _Right);
template<class _Ty, class _Pr> inline
    const _Ty max(const _Ty% _Left, const _Ty% _Right, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria maxstandard C++. Per altre informazioni, vedere max.

max_element (STL/CLR)

Trova la prima occorrenza dell'elemento più grande in un intervallo specificato in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _FwdIt> inline
    _FwdIt max_element(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria max_elementstandard C++. Per altre informazioni, vedere max_element.

merge (STL/CLR)

Combina tutti gli elementi di due intervalli di origine ordinati in un unico intervallo di destinazione ordinato, in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt merge(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt merge(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria mergestandard C++. Per altre informazioni, vedere merge.

min (STL/CLR)

Confronta due oggetti e restituisce il minore dei due in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _Ty> inline
    const _Ty min(const _Ty% _Left, const _Ty% _Right);
template<class _Ty, class _Pr> inline
    const _Ty min(const _Ty% _Left, const _Ty% _Right, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria minstandard C++. Per altre informazioni, vedere min.

min_element (STL/CLR)

Trova la prima occorrenza dell'elemento più piccolo in un intervallo specificato in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _FwdIt> inline
    _FwdIt min_element(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria min_elementstandard C++. Per altre informazioni, vedere min_element.

mismatch (STL/CLR)

Confronta due intervalli elemento per elemento per verificarne l'uguaglianza o l'equivalenza nel senso specificato da un predicato binario e individua la prima posizione in cui viene riscontrata una differenza.

Sintassi

template<class _InIt1, class _InIt2> inline
    _PAIR_TYPE(_InIt1)
        mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2);
template<class _InIt1, class _InIt2, class _Pr> inline
    _PAIR_TYPE(_InIt1)
        mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
            _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria mismatchstandard C++. Per altre informazioni, vedere Mancata corrispondenza.

next_permutation (STL/CLR)

Riordina gli elementi in un intervallo in modo che l'ordine originale venga sostituito dalla maggior permutazione a livello lessicografico successiva, se esiste, dove il senso di successivo può essere specificato con un predicato binario.

Sintassi

template<class _BidIt> inline
    bool next_permutation(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria next_permutationstandard C++. Per altre informazioni, vedere next_permutation.

nth_element (STL/CLR)

Partiziona un intervallo di elementi, individuando correttamente l'elemento nth della sequenza nell'intervallo in modo che tutti gli elementi di fronte a esso siano minori o uguali a esso e tutti gli elementi che lo seguono nella sequenza sono maggiori o uguali a esso.

Sintassi

template<class _RanIt> inline
    void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last,
        _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria nth_elementstandard C++. Per altre informazioni, vedere nth_element.

partial_sort (STL/CLR)

Dispone un numero specificato di elementi più piccoli di un intervallo in un ordine non decrescente o secondo un criterio di ordinamento specificato da un predicato binario.

Sintassi

template<class _RanIt> inline
    void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last,
        _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria partial_sortstandard C++. Per altre informazioni, vedere partial_sort.

partial_sort_copy (STL/CLR)

Copia gli elementi di un intervallo di origine in un intervallo di destinazione in cui gli elementi di origine sono ordinati in base al predicato binario relativo al valore inferiore o a un altro predicato binario specificato.

Sintassi

template<class _InIt, class _RanIt> inline
    _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,
        _RanIt _First2, _RanIt _Last2);
template<class _InIt, class _RanIt, class _Pr> inline
    _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,
        _RanIt _First2, _RanIt _Last2, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria partial_sort_copystandard C++. Per altre informazioni, vedere partial_sort_copy.

partition (STL/CLR)

Classifica gli elementi di un intervallo in due set non contigui, con gli elementi che soddisfano il predicato unario che precedono quelli che non lo soddisfano.

Sintassi

template<class _BidIt, class _Pr> inline
    _BidIt partition(_BidIt _First, _BidIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria partitionstandard C++. Per altre informazioni, vedere partizione.

pop_heap (STL/CLR)

Rimuove l'elemento più grande dall'inizio di un heap alla penultima posizione nell'intervallo e costituisce un nuovo heap con gli elementi rimanenti.

Sintassi

template<class _RanIt> inline
    void pop_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria pop_heapstandard C++. Per altre informazioni, vedere pop_heap.

prev_permutation (STL/CLR)

Riordina gli elementi in un intervallo in modo che l'ordine originale venga sostituito dalla maggior permutazione a livello lessicografico successiva, se esiste, dove il senso di successivo può essere specificato con un predicato binario.

Sintassi

template<class _BidIt> inline
    bool prev_permutation(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria prev_permutationstandard C++. Per altre informazioni, vedere prev_permutation.

push_heap (STL/CLR)

Aggiunge un elemento che si trova alla fine di un intervallo a un heap esistente costituito dagli elementi precedenti dell'intervallo.

Sintassi

template<class _RanIt> inline
    void push_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria push_heapstandard C++. Per altre informazioni, vedere push_heap.

random_shuffle (STL/CLR)

Riorganizzare una sequenza di N elementi in un intervallo in uno di N. possibili disposizioni selezionate in modo casuale.

Sintassi

template<class _RanIt> inline
    void random_shuffle(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Fn1> inline
    void random_shuffle(_RanIt _First, _RanIt _Last, _Fn1% _Func);

Osservazioni:

Questa funzione si comporta come la funzione della libreria random_shufflestandard C++. Per altre informazioni, vedere random_shuffle.

remove (STL/CLR)

Elimina un valore specificato da un intervallo specificato senza alterare l'ordine degli elementi rimanenti e restituendo la fine di un nuovo intervallo senza il valore specificato.

Sintassi

template<class _FwdIt, class _Ty> inline
    _FwdIt remove(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria removestandard C++. Per altre informazioni, vedere Remove.

remove_copy (STL/CLR)

Copia gli elementi di un intervallo di origine in un intervallo di destinazione, ad eccezione degli elementi di un determinato valore, senza alterare l'ordine degli elementi rimanenti e restituendo la fine di un nuovo intervallo di destinazione.

Sintassi

template<class _InIt, class _OutIt, class _Ty> inline
    _OutIt remove_copy(_InIt _First, _InIt _Last,
        _OutIt _Dest, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria remove_copystandard C++. Per altre informazioni, vedere remove_copy.

remove_copy_if (STL/CLR)

Copia gli elementi di un intervallo di origine in un intervallo di destinazione, ad eccezione degli elementi che soddisfano un predicato, senza alterare l'ordine degli elementi rimanenti e restituendo la fine di un nuovo intervallo di destinazione.

Sintassi

template<class _InIt, class _OutIt, class _Pr> inline
    _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria remove_copy_ifstandard C++. Per altre informazioni, vedere remove_copy_if.

remove_if (STL/CLR)

Elimina gli elementi che soddisfano un predicato da un intervallo specificato senza alterare l'ordine degli elementi rimanenti e restituendo la fine di un nuovo intervallo senza il valore specificato.

Sintassi

template<class _FwdIt, class _Pr> inline
    _FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria remove_ifstandard C++. Per altre informazioni, vedere remove_if.

replace (STL/CLR)

Esamina ogni elemento di un intervallo e lo sostituisce se corrisponde a un valore specificato.

Sintassi

template<class _FwdIt, class _Ty> inline
    void replace(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Oldval, const _Ty% _Newval);

Osservazioni:

Questa funzione si comporta come la funzione della libreria replacestandard C++. Per altre informazioni, vedere Replace.

replace_copy (STL/CLR)

Esamina ogni elemento di un intervallo di origine e lo sostituisce se corrisponde a un valore specificato copiando nel contempo il risultato in un nuovo intervallo di destinazione.

Sintassi

template<class _InIt, class _OutIt, class _Ty> inline
    _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
        const _Ty% _Oldval, const _Ty% _Newval);

Osservazioni:

Questa funzione si comporta come la funzione della libreria replace_copystandard C++. Per altre informazioni, vedere replace_copy.

replace_copy_if (STL/CLR)

Esamina ogni elemento di un intervallo di origine e lo sostituisce se soddisfa un predicato specificato copiando nel contempo il risultato in un nuovo intervallo di destinazione.

Sintassi

template<class _InIt, class _OutIt, class _Pr, class _Ty> inline
    _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred, const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria replace_copy_ifstandard C++. Per altre informazioni, vedere replace_copy_if.

replace_if (STL/CLR)

Esamina ogni elemento di un intervallo e lo sostituisce se soddisfa un predicato specificato.

Sintassi

template<class _FwdIt, class _Pr, class _Ty> inline
    void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred,
        const _Ty% _Val);

Osservazioni:

Questa funzione si comporta come la funzione della libreria replace_ifstandard C++. Per altre informazioni, vedere replace_if.

reverse (STL/CLR)

Inverte l'ordine degli elementi all'interno di un intervallo.

Sintassi

template<class _BidIt> inline
    void reverse(_BidIt _First, _BidIt _Last);

Osservazioni:

Questa funzione si comporta come la funzione della libreria reversestandard C++. Per altre informazioni, vedere invertire.

reverse_copy (STL/CLR)

Inverte l'ordine degli elementi all'interno di un intervallo di origine durante la copia in un intervallo di destinazione.

Sintassi

template<class _BidIt, class _OutIt> inline
    _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest);

Osservazioni:

Questa funzione si comporta come la funzione della libreria reverse_copystandard C++. Per altre informazioni, vedere reverse_copy.

rotate (STL/CLR)

Scambia gli elementi di due intervalli adiacenti.

Sintassi

template<class _FwdIt> inline
    void rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last);

Osservazioni:

Questa funzione si comporta come la funzione della libreria rotatestandard C++. Per altre informazioni, vedere Ruotare.

rotate_copy (STL/CLR)

Scambia gli elementi di due intervalli adiacenti all'interno di un intervallo di origine e copia il risultato in un intervallo di destinazione.

Sintassi

template<class _FwdIt, class _OutIt> inline
    _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last,
        _OutIt _Dest);

Osservazioni:

Questa funzione si comporta come la funzione della libreria rotate_copystandard C++. Per altre informazioni, vedere rotate_copy.

search (STL/CLR)

Cerca la prima occorrenza di una sequenza all'interno di un intervallo di destinazione i cui elementi sono uguali a quelli di una sequenza specificata di elementi oppure i cui elementi sono equivalenti nel senso specificato da un predicato binario agli elementi della sequenza specificata.

Sintassi

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
    _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria searchstandard C++. Per altre informazioni, vedere Ricerca.

search_n (STL/CLR)

Cerca la prima sottosequenza di un intervallo di un numero specificato di elementi che dispongono di un valore specifico o di una relazione con tale valore come specificato da un predicato binario.

Sintassi

template<class _FwdIt1, class _Diff2, class _Ty> inline
    _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
        _Diff2 _Count, const _Ty& _Val);
template<class _FwdIt1, class _Diff2, class _Ty, class _Pr> inline
    _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
        _Diff2 _Count, const _Ty& _Val, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria search_nstandard C++. Per altre informazioni, vedere search_n.

set_difference (STL/CLR)

Unisce tutti gli elementi appartenenti a un intervallo di origine ordinato, ma non a un secondo intervallo di origine ordinato, in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2,_OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria set_differencestandard C++. Per altre informazioni, vedere set_difference.

set_intersection (STL/CLR)

Unisce tutti gli elementi appartenenti a entrambi gli intervalli di origine ordinati in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria set_intersectionstandard C++. Per altre informazioni, vedere set_intersection.

set_symmetric_difference (STL/CLR)

Unisce tutti gli elementi appartenenti a uno degli intervalli di origine ordinati, ma non ad entrambi, in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria set_symmetric_differencestandard C++. Per altre informazioni, vedere set_symmetric_difference.

set_union (STL/CLR)

Unisce tutti gli elementi appartenenti almeno a uno dei due intervalli di origine ordinati in un unico intervallo di destinazione ordinato in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria set_unionstandard C++. Per altre informazioni, vedere set_union.

sort (STL/CLR)

Dispone gli elementi di un intervallo specificato in un ordine non decrescente o secondo un criterio di ordinamento specificato da un predicato binario.

Sintassi

template<class _RanIt> inline
    void sort(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void sort(_RanIt _First, _RanIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria sortstandard C++. Per altre informazioni, vedere Ordinare.

sort_heap (STL/CLR)

Converte un heap in un intervallo ordinato.

Sintassi

template<class _RanIt> inline
    void sort_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria sort_heapstandard C++. Per altre informazioni, vedere sort_heap.

stable_partition (STL/CLR)

Classifica gli elementi di un intervallo in due set non contigui, con gli elementi che soddisfano un predicato unario che precedono quelli che non lo soddisfano, mantenendo l'ordine relativo degli elementi equivalenti.

Sintassi

template<class _BidIt, class _Pr> inline
    _BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria stable_partitionstandard C++. Per altre informazioni, vedere stable_partition.

stable_sort (STL/CLR)

Dispone gli elementi di un intervallo specificato in un ordine non decrescente o secondo un criterio di ordinamento specificato da un predicato binario e mantiene l'ordinamento relativo degli elementi equivalenti.

Sintassi

template<class _BidIt> inline
    void stable_sort(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    void stable_sort(_BidIt _First, _BidIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria stable_sortstandard C++. Per altre informazioni, vedere stable_sort.

swap (STL/CLR)

Scambia i valori degli elementi tra due tipi di oggetti, assegnando il contenuto del primo oggetto al secondo oggetto e il contenuto del secondo al primo.

Sintassi

<class _Ty> inline
    void swap(_Ty% _Left, _Ty% _Right);

Osservazioni:

Questa funzione si comporta come la funzione della libreria swapstandard C++. Per altre informazioni, vedere Swap.

swap_ranges (STL/CLR)

Scambia gli elementi di un intervallo con gli elementi di un altro intervallo di uguali dimensioni.

Sintassi

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2);

Osservazioni:

Questa funzione si comporta come la funzione della libreria swap_rangesstandard C++. Per altre informazioni, vedere swap_ranges.

transform (STL/CLR)

Applica un oggetto funzione ad ogni elemento di un intervallo di origine o a una coppia di elementi di due intervalli di origine e copia i valori restituiti dell'oggetto funzione in un intervallo di destinazione.

Sintassi

template<class _InIt, class _OutIt, class _Fn1> inline
    _OutIt transform(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Fn1 _Func);
template<class _InIt1, class _InIt2, class _OutIt, class _Fn2> inline
    _OutIt transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
        _OutIt _Dest, _Fn2 _Func);

Osservazioni:

Questa funzione si comporta come la funzione della libreria transformstandard C++. Per altre informazioni, vedere Transform.

unique (STL/CLR)

Rimuove gli elementi duplicati adiacenti l'uno rispetto all'altro in un intervallo specificato.

Sintassi

template<class _FwdIt> inline
    _FwdIt unique(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria uniquestandard C++. Per altre informazioni, vedere unique.

unique_copy (STL/CLR)

Copia gli elementi di un intervallo di origine in un intervallo di destinazione ad eccezione degli elementi duplicati adiacenti l'uno rispetto all'altro.

Sintassi

template<class _InIt, class _OutIt> inline
    _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest);
template<class _InIt, class _OutIt, class _Pr> inline
    _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria unique_copystandard C++. Per altre informazioni, vedere unique_copy.

upper_bound (STL/CLR)

Trova la posizione del primo elemento in un intervallo ordinato con un valore maggiore di un valore specificato, in cui il criterio di ordinamento può essere specificato da un predicato binario.

Sintassi

template<class _FwdIt, class _Ty> inline
    _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Osservazioni:

Questa funzione si comporta come la funzione della libreria upper_boundstandard C++. Per altre informazioni, vedere upper_bound.