algorithm (STL/CLR)

Define plantillas de función de contenedor STL/CLR que realizan algoritmos.

Sintaxis

#include <cliext/algorithm>

Requisitos

Encabezado:<cliext/algorithm>

Espacio de nombres: cliext

Declaraciones

Función	Descripción
adjacent_find (STL/CLR)	Busca dos elementos adyacentes que son iguales.
binary_search (STL/CLR)	Comprueba si una secuencia ordenada contiene un valor determinado.
copy (STL/CLR)	Copia valores de un intervalo de origen en un intervalo de destino, iterando en la dirección de avance.
copy_backward (STL/CLR)	Copia valores de un intervalo de origen en un intervalo de destino, iterando en la dirección de retroceso.
count (STL/CLR)	Devuelve el número de elementos de un intervalo cuyos valores coinciden con un valor especificado.
count_if (STL/CLR)	Devuelve el número de elementos de un intervalo cuyos valores coinciden con una condición especificada.
equal (STL/CLR)	Compara dos intervalos, elemento por elemento.
equal_range (STL/CLR)	Busca en una secuencia ordenada de valores y devuelve dos posiciones que delimitan una subsecuencia de valores que son todos iguales a un elemento determinado.
fill (STL/CLR)	Asigna el mismo valor nuevo a cada elemento de un intervalo especificado.
fill_n (STL/CLR)	Asigna un nuevo valor a un número especificado de elementos de un intervalo a partir de un elemento determinado.
find (STL/CLR)	Devuelve la posición de la primera aparición de un valor especificado.
find_end (STL/CLR)	Devuelve la última subsecuencia de un intervalo idéntico a una secuencia especificada.
find_first_of (STL/CLR)	Busca en un rango la primera aparición de cualquiera de un intervalo de elementos determinado.
find_if (STL/CLR)	Devuelve la posición del primer elemento en una secuencia de valores donde el elemento cumple una condición especificada.
for_each (STL/CLR)	Aplica un objeto de función especificado a cada elemento en una secuencia de valores y devuelve el objeto de función.
generate (STL/CLR)	Asigna los valores generados por un objeto de función a cada elemento de una secuencia de valores.
generate_n (STL/CLR)	Asigna los valores generados por un objeto de función a un número especificado de elementos.
includes (STL/CLR)	Comprueba si un intervalo ordenado contiene todos los elementos de un segundo intervalo ordenado.
inplace_merge (STL/CLR)	Combina los elementos de dos intervalos ordenados consecutivos en un único intervalo ordenado.
iter_swap (STL/CLR)	Intercambia dos valores a los que se hace referencia mediante un par de iteradores especificados.
lexicographical_compare (STL/CLR)	Compara dos secuencias, elemento por elemento, que identifica qué secuencia es la menor de las dos.
lower_bound (STL/CLR)	Encuentra la posición del primer elemento en una secuencia ordenada de valores que tiene un valor mayor o igual a un valor especificado.
make_heap (STL/CLR)	Convierte los elementos de un intervalo especificado en un montón donde el primer elemento del montón es el más grande.
max (STL/CLR)	Compara dos objetos y devuelve el mayor de los dos.
max_element (STL/CLR)	Busca el elemento más grande en una secuencia de valores especificada.
merge (STL/CLR)	Combina todos los elementos de dos intervalos de origen ordenados en un único intervalo de destino ordenado.
min (STL/CLR)	Compara dos objetos y devuelve el menor de los dos.
min_element (STL/CLR)	Busca el elemento más pequeño en una secuencia de valores especificada.
mismatch (STL/CLR)	Compara dos intervalos elemento a elemento y devuelve la primera posición en la que se produce una diferencia.
next_permutation (STL/CLR)	Reorganiza los elementos de un intervalo de modo que la ordenación original se reemplaza con la mayor permutación lexicográficamente siguiente si existe.
nth_element (STL/CLR)	Divide una secuencia de elementos, situando correctamente el n elemento de la secuencia de modo que todos los elementos que hay delante sean menores o iguales que él y todos los que lo siguen sean mayores o iguales que él.
partial_sort (STL/CLR)	Organiza un número especificado de los elementos más pequeños de un intervalo en orden no descendente.
partial_sort_copy (STL/CLR)	Copia elementos de un intervalo de origen en un intervalo de destino de modo que se ordenan los elementos del intervalo de origen.
partition (STL/CLR)	Organiza los elementos de un intervalo de modo que esos elementos que cumplen un predicado unario preceden a los que no lo cumplen.
pop_heap (STL/CLR)	Mueve el elemento mayor del principio de un montón hasta el final y después forma un nuevo montón con los elementos restantes.
prev_permutation (STL/CLR)	Reorganiza una secuencia de elementos de modo que la ordenación original se reemplaza con la mayor permutación lexicográficamente anterior si existe.
push_heap (STL/CLR)	Agrega un elemento que está al final de un intervalo a un montón existente que se compone de los elementos anteriores del intervalo.
random_shuffle (STL/CLR)	Reorganiza una secuencia de N elementos de un intervalo en una de N! organizaciones posibles seleccionadas aleatoriamente.
remove (STL/CLR)	Elimina un valor especificado de un intervalo determinado sin alterar el orden de los elementos restantes y devolver el final de un nuevo intervalo libre del valor especificado.
remove_copy (STL/CLR)	Copia elementos de un intervalo de origen a un intervalo de destino, excepto que los elementos de un valor especificado no se copian, sin alterar el orden de los elementos restantes.
remove_copy_if (STL/CLR)	Copia elementos de un intervalo de origen a un intervalo de destino, excepto aquellos que cumplen un predicado, sin alterar el orden de los elementos restantes.
remove_if (STL/CLR)	Elimina los elementos que cumplen un predicado de un intervalo determinado sin alterar el orden de los elementos restantes. .
replace (STL/CLR)	Reemplaza los elementos de un intervalo que coinciden con un valor especificado por un nuevo valor.
replace_copy (STL/CLR)	Copia los elementos de un intervalo de origen en un intervalo de destino, reemplazando los elementos que coinciden con un valor especificado por un nuevo valor.
replace_copy_if (STL/CLR)	Examina cada elemento de un intervalo de origen y lo reemplaza si satisface un predicado especificado y copia el resultado a un nuevo intervalo de destino.
replace_if (STL/CLR)	Examina cada elemento de un intervalo y lo reemplaza si satisface un predicado especificado.
reverse (STL/CLR)	Invierte el orden de los elementos dentro de un intervalo.
reverse_copy (STL/CLR)	Invierte el orden de los elementos dentro de un intervalo de origen mientras los copia a un intervalo de destino.
rotate (STL/CLR)	Intercambia los elementos de dos intervalos adyacentes.
rotate_copy (STL/CLR)	Intercambia los elementos de dos intervalos adyacentes dentro de un intervalo de origen y copia el resultado a un intervalo de destino.
search (STL/CLR)	Busca la primera aparición de una secuencia dentro de un intervalo de destino cuyos elementos son iguales que los de una secuencia determinada de elementos o cuyos elementos son equivalentes según lo especificado por un predicado binario a los elementos de la secuencia especificada.
search_n (STL/CLR)	Busca la primera subsecuencia de un intervalo en la que un número especificado de elementos tienen un valor determinado o una relación con ese valor según lo especificado por un predicado binario.
set_difference (STL/CLR)	Agrupa todos los elementos que pertenecen a un intervalo de origen ordenado, pero no a un segundo intervalo de origen ordenado, en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.
set_intersection (STL/CLR)	Agrupa todos los elementos que pertenecen a ambos intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.
set_symmetric_difference (STL/CLR)	Agrupa todos los elementos que pertenecen a uno, pero no a ambos, de los intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.
set_union (STL/CLR))	Agrupa todos los elementos que pertenecen al menos a uno de los dos intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.
sort (STL/CLR)	Organiza los elementos de un intervalo especificado en un orden no descendente o de acuerdo con un criterio de ordenación especificado por un predicado binario.
sort_heap (STL/CLR)	Convierte un montón en un intervalo ordenado.
stable_partition (STL/CLR)	Clasifica los elementos de un intervalo en dos conjuntos disjuntos, donde los elementos que satisfacen un predicado unario preceden a los que no lo satisfacen, conservando el orden relativo de los elementos equivalentes.
stable_sort (STL/CLR)	Organiza los elementos de un intervalo especificado en un orden no descendente o de acuerdo con un criterio de ordenación especificado por un predicado binario y conserva el orden relativo de los elementos equivalentes.
swap (STL/CLR)	Intercambia los valores de los elementos entre dos tipos de objetos, asignando el contenido del primer objeto al segundo objeto y el contenido del segundo al primero.
swap_ranges (STL/CLR)	Intercambia los elementos de un intervalo con los elementos de otro intervalo del mismo tamaño.
transform (STL/CLR)	Aplica un objeto de función especificado a cada elemento de un intervalo de origen o a un par de elementos de dos intervalos de origen y copia los valores devueltos del objeto de función a un intervalo de destino.
unique (STL/CLR)	Quita los elementos duplicados adyacentes entre sí en un intervalo especificado.
unique_copy (STL/CLR)	Copia los elementos de un intervalo de origen a un intervalo de destino salvo los elementos duplicados que son adyacentes entre sí.
upper_bound (STL/CLR)	Busca la posición del primer elemento de un intervalo ordenado que tiene un valor mayor que un valor especificado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Miembros

adjacent_find (STL/CLR)

Busca dos elementos adyacentes que son iguales o cumplen una condición especificada.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función adjacent_find de la biblioteca estándar de C++. Para obtener más información, consulte adjacent_find.

binary_search (STL/CLR)

Comprueba si hay un elemento en un intervalo ordenado que sea igual a un valor especificado o equivalente a este del modo especificado por un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función binary_search de la biblioteca estándar de C++. Para obtener más información, consulte binary_search.

copy (STL/CLR)

Asigna los valores de elementos de un intervalo de origen a un intervalo de destino, recorriendo en iteración la secuencia de origen de elementos y asignándoles nuevas posiciones en una dirección hacia delante.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función copy de la biblioteca estándar de C++. Para obtener más información, consulte copy.

copy_backward (STL/CLR)

Asigna los valores de elementos de un intervalo de origen a un intervalo de destino, recorriendo en iteración la secuencia de origen de elementos y asignándoles nuevas posiciones en una dirección hacia atrás.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función copy_backward de la biblioteca estándar de C++. Para obtener más información, consulte copy_backward.

count (STL/CLR)

Devuelve el número de elementos de un intervalo cuyos valores coinciden con un valor especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función count de la biblioteca estándar de C++. Para obtener más información, consulte count.

count_if (STL/CLR)

Devuelve el número de elementos de un intervalo cuyos valores coinciden con una condición especificada.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función count_if de la biblioteca estándar de C++. Para obtener más información, consulte count_if.

equal (STL/CLR)

Compara dos intervalos elemento a elemento para ver si son iguales o equivalentes según lo especificado por un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función equal de la biblioteca estándar de C++. Para obtener más información, consulte equal.

equal_range (STL/CLR)

Busca un par de posiciones en un intervalo ordenado; la primera es menor o equivalente a la posición de un elemento especificado y la segunda es mayor que la posición del elemento, donde el sentido de equivalencia o de ordenación empleado para establecer las posiciones en la secuencia se puede especificar con un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función equal_range de la biblioteca estándar de C++. Para obtener más información, consulte equal_range.

fill (STL/CLR)

Asigna el mismo valor nuevo a cada elemento de un intervalo especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función fill de la biblioteca estándar de C++. Para obtener más información, consulte fill.

fill_n (STL/CLR)

Asigna un nuevo valor a un número especificado de elementos de un intervalo a partir de un elemento determinado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función fill_n de la biblioteca estándar de C++. Para obtener más información, consulte fill_n.

find (STL/CLR)

Busca la posición de la primera aparición de un elemento en un intervalo que tiene un valor especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función find de la biblioteca estándar de C++. Para obtener más información, consulte find.

find_end (STL/CLR)

Busca en un intervalo la última subsecuencia que es idéntica a una secuencia especificada o que es equivalente según lo especificado por un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función find_end de la biblioteca estándar de C++. Para obtener más información, consulte find_end.

find_first_of (STL/CLR)

Busca la primera aparición de cualquiera de varios valores dentro de un intervalo de destino o la primera aparición de cualquiera de varios elementos que son equivalentes según lo especificado por un predicado binario en un conjunto especificado de los elementos.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función find_first_of de la biblioteca estándar de C++. Para obtener más información, consulte find_first_of.

find_if (STL/CLR)

Busca la posición de la primera aparición de un elemento en un intervalo que cumple una condición especificada.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función find_if de la biblioteca estándar de C++. Para obtener más información, consulte find_if.

for_each (STL/CLR)

Aplica un objeto de función especificado a cada elemento en un orden hacia delante dentro de un intervalo y devuelve el objeto de función.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función for_each de la biblioteca estándar de C++. Para obtener más información, consulte for_each.

generate (STL/CLR)

Asigna los valores generados por un objeto de función a cada elemento de un intervalo.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función generate de la biblioteca estándar de C++. Para obtener más información, vea generar.

generate_n (STL/CLR)

Asigna los valores generados por un objeto de función a un número especificado de elemento de un intervalo y vuelve a la posición situada una más allá del último valor asignado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función generate_n de la biblioteca estándar de C++. Para obtener más información, consulte generate_n.

includes (STL/CLR)

Prueba si un intervalo ordenado contiene todos los elementos incluidos en un segundo intervalo ordenado, donde el criterio de ordenación o equivalencia entre los elementos se pueden especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función includes de la biblioteca estándar de C++. Para obtener más información, consulte includes.

inplace_merge (STL/CLR)

Combina los elementos de dos intervalos ordenados consecutivos en un único intervalo ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función inplace_merge de la biblioteca estándar de C++ Para obtener más información, consulte inplace_merge.

iter_swap (STL/CLR)

Intercambia dos valores a los que se hace referencia mediante un par de iteradores especificados.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función iter_swap de la biblioteca estándar de C++. Para obtener más información, consulte iter_swap.

lexicographical_compare (STL/CLR)

Compara dos secuencias elemento a elemento para determinar cuál es menor de los dos.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función lexicographical_compare de la biblioteca estándar de C++. Para obtener más información, consulte lexicographical_compare.

lower_bound (STL/CLR)

Busca la posición del primer elemento en un intervalo ordenado que tiene un valor menor o equivalente a un valor especificado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función lower_bound de la biblioteca estándar de C++. Para obtener más información, consulte lower_bound.

make_heap (STL/CLR)

Convierte elementos de un intervalo especificado en un montón en el que el primer elemento es el mayor y para el que se puede especificar un criterio de ordenación con un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función make_heap de la biblioteca estándar de C++. Para obtener más información, consulte make_heap.

max (STL/CLR)

Compara dos objetos y devuelve el mayor de los dos, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función max de la biblioteca estándar de C++. Para obtener más información, consulte max.

max_element (STL/CLR)

Busca la primera aparición del elemento mayor en un intervalo especificado donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función max_element de la biblioteca estándar de C++. Para obtener más información, consulte max_element.

merge (STL/CLR)

Combina todos los elementos de dos intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función merge de la biblioteca estándar de C++. Para obtener más información, consulte merge.

min (STL/CLR)

Compara dos objetos y devuelve el menor de los dos, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función min de la biblioteca estándar de C++. Para obtener más información, consulte min.

min_element (STL/CLR)

Busca la primera aparición del menor elemento en un intervalo especificado donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función min_element de la biblioteca estándar de C++. Para obtener más información, consulte min_element.

mismatch (STL/CLR)

Compara dos intervalos elemento a elemento para ver si son iguales o equivalentes según lo especificado por un predicado binario y busca la primera posición donde se produce una diferencia.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función mismatch de la biblioteca estándar de C++. Para obtener más información, consulte mismatch.

next_permutation (STL/CLR)

Reorganiza los elementos de un intervalo de modo que la ordenación original se reemplaza con la mayor permutación lexicográficamente siguiente si existe, donde el sentido de siguiente se puede especificar con un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función next_permutation de la biblioteca estándar de C++. Para obtener más información, consulte next_permutation.

nth_element (STL/CLR)

Divide un intervalo de elementos, situando correctamente el n elemento de la secuencia en el intervalo de modo que todos los elementos que hay delante sean menores o iguales que él y todos los que lo siguen en la secuencia sean mayores o iguales que él.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función nth_element de la biblioteca estándar de C++. Para obtener más información, consulte nth_element.

partial_sort (STL/CLR)

Organiza un número especificado de los elementos menores de un intervalo en un orden no descendente, o de acuerdo con un criterio de ordenación especificado por un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función partial_sort de la biblioteca estándar de C++. Para obtener más información, consulte partial_sort.

partial_sort_copy (STL/CLR)

Copia los elementos de un intervalo de origen a un intervalo de destino donde los elementos de origen están ordenados por menor que u otro predicado binario especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función partial_sort_copy de la biblioteca estándar de C++. Para obtener más información, consulte partial_sort_copy.

partition (STL/CLR)

Clasifica los elementos de un intervalo en dos conjuntos disjuntos, donde los elementos que satisfacen un predicado unario preceden a los que no lo satisfacen.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función partition de la biblioteca estándar de C++. Para obtener más información, consulte partition.

pop_heap (STL/CLR)

Quita el elemento mayor del principio de un montón hasta la penúltima posición del intervalo y después forma un nuevo montón con los elementos restantes.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función pop_heap de la biblioteca estándar de C++. Para obtener más información, consulte pop_heap.

prev_permutation (STL/CLR)

Reorganiza los elementos de un intervalo de modo que la ordenación original se reemplaza con la mayor permutación lexicográficamente siguiente si existe, donde el sentido de siguiente se puede especificar con un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función prev_permutation de la biblioteca estándar de C++. Para obtener más información, consulte prev_permutation.

push_heap (STL/CLR)

Agrega un elemento que está al final de un intervalo a un montón existente que se compone de los elementos anteriores del intervalo.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función push_heap de la biblioteca estándar de C++. Para obtener más información, consulte push_heap.

random_shuffle (STL/CLR)

Reorganiza una secuencia de N elementos de un intervalo en una de N! organizaciones posibles seleccionadas aleatoriamente.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función random_shuffle de la biblioteca estándar de C++. Para obtener más información, consulte random_shuffle.

remove (STL/CLR)

Elimina un valor especificado de un intervalo determinado sin alterar el orden de los elementos restantes y devolver el final de un nuevo intervalo libre del valor especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función remove de la biblioteca estándar de C++. Para obtener más información, consulte remove.

remove_copy (STL/CLR)

Copia elementos de un intervalo de origen a un intervalo de destino, excepto que los elementos de un valor especificado no se copian, sin alterar el orden de los elementos restantes y devolver el final de un nuevo intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función remove_copy de la biblioteca estándar de C++. Para obtener más información, consulte remove_copy.

remove_copy_if (STL/CLR)

Copia elementos de un intervalo de origen a un intervalo de destino, excepto que los elementos que satisfacen un predicado no se copian, sin alterar el orden de los elementos restantes y devolver el final de un nuevo intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función remove_copy_if de la biblioteca estándar de C++. Para obtener más información, consulte remove_copy_if.

remove_if (STL/CLR)

Elimina los elementos que cumplen un predicado de un intervalo determinado sin alterar el orden de los elementos restantes y devolver el final de un nuevo intervalo libre del valor especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función remove_if de la biblioteca estándar de C++. Para obtener más información, consulte remove_if.

replace (STL/CLR)

Examina cada elemento de un intervalo y lo reemplaza si coincide con un valor especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función replace de la biblioteca estándar de C++. Para obtener más información, consulte replace.

replace_copy (STL/CLR)

Examina cada elemento de un intervalo de origen y lo reemplaza si coincide con un valor especificado y copia el resultado a un nuevo intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función replace_copy de la biblioteca estándar de C++. Para obtener más información, consulte replace_copy.

replace_copy_if (STL/CLR)

Examina cada elemento de un intervalo de origen y lo reemplaza si satisface un predicado especificado y copia el resultado a un nuevo intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función replace_copy_if de la biblioteca estándar de C++. Para obtener más información, consulte replace_copy_if.

replace_if (STL/CLR)

Examina cada elemento de un intervalo y lo reemplaza si satisface un predicado especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función replace_if de la biblioteca estándar de C++. Para obtener más información, consulte replace_if.

reverse (STL/CLR)

Invierte el orden de los elementos dentro de un intervalo.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función reverse de la biblioteca estándar de C++. Para obtener más información, consulte reverse.

reverse_copy (STL/CLR)

Invierte el orden de los elementos dentro de un intervalo de origen mientras los copia a un intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función reverse_copy de la biblioteca estándar de C++. Para obtener más información, consulte reverse_copy.

rotate (STL/CLR)

Intercambia los elementos de dos intervalos adyacentes.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función rotate de la biblioteca estándar de C++. Para obtener más información, consulte rotate.

rotate_copy (STL/CLR)

Intercambia los elementos de dos intervalos adyacentes dentro de un intervalo de origen y copia el resultado a un intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función rotate_copy de la biblioteca estándar de C++. Para obtener más información, consulte rotate_copy.

search (STL/CLR)

Busca la primera aparición de una secuencia dentro de un intervalo de destino cuyos elementos son iguales que los de una secuencia determinada de elementos o cuyos elementos son equivalentes según lo especificado por un predicado binario a los elementos de la secuencia especificada.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función search de la biblioteca estándar de C++. Para obtener más información, consulte search.

search_n (STL/CLR)

Busca la primera subsecuencia de un intervalo en la que un número especificado de elementos tienen un valor determinado o una relación con ese valor según lo especificado por un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función search_n de la biblioteca estándar de C++. Para obtener más información, consulte search_n.

set_difference (STL/CLR)

Agrupa todos los elementos que pertenecen a un intervalo de origen ordenado, pero no a un segundo intervalo de origen ordenado, en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función set_difference de la biblioteca estándar de C++. Para obtener más información, consulte set_difference.

set_intersection (STL/CLR)

Agrupa todos los elementos que pertenecen a ambos intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función set_intersection de la biblioteca estándar de C++. Para obtener más información, consulte set_intersection.

set_symmetric_difference (STL/CLR)

Agrupa todos los elementos que pertenecen a uno, pero no a ambos, de los intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función set_symmetric_difference de la biblioteca estándar de C++. Para obtener más información, consulte set_symmetric_difference.

set_union (STL/CLR)

Agrupa todos los elementos que pertenecen al menos a uno de los dos intervalos de origen ordenados en un único intervalo de destino ordenado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función set_union de la biblioteca estándar de C++. Para obtener más información, consulte set_union.

sort (STL/CLR)

Organiza los elementos de un intervalo especificado en un orden no descendente o de acuerdo con un criterio de ordenación especificado por un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función sort de la biblioteca estándar de C++. Para obtener más información, consulte sort.

sort_heap (STL/CLR)

Convierte un montón en un intervalo ordenado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función sort_heap de la biblioteca estándar de C++. Para obtener más información, consulte sort_heap.

stable_partition (STL/CLR)

Clasifica los elementos de un intervalo en dos conjuntos disjuntos, donde los elementos que satisfacen un predicado unario preceden a los que no lo satisfacen, conservando el orden relativo de los elementos equivalentes.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función stable_partition de la biblioteca estándar de C++. Para obtener más información, consulte stable_partition.

stable_sort (STL/CLR)

Organiza los elementos de un intervalo especificado en un orden no descendente o de acuerdo con un criterio de ordenación especificado por un predicado binario y conserva el orden relativo de los elementos equivalentes.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función stable_sort de la biblioteca estándar de C++. Para obtener más información, consulte stable_sort.

swap (STL/CLR)

Intercambia los valores de los elementos entre dos tipos de objetos, asignando el contenido del primer objeto al segundo objeto y el contenido del segundo al primero.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función swap de la biblioteca estándar de C++. Para obtener más información, consulte swap.

swap_ranges (STL/CLR)

Intercambia los elementos de un intervalo con los elementos de otro intervalo del mismo tamaño.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función swap_ranges de la biblioteca estándar de C++. Para obtener más información, consulte swap_ranges.

transform (STL/CLR)

Aplica un objeto de función especificado a cada elemento de un intervalo de origen o a un par de elementos de dos intervalos de origen y copia los valores devueltos del objeto de función a un intervalo de destino.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función transform de la biblioteca estándar de C++. Para obtener más información, consulte transform.

unique (STL/CLR)

Quita los elementos duplicados adyacentes entre sí en un intervalo especificado.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función unique de la biblioteca estándar de C++. Para obtener más información, consulte unique.

unique_copy (STL/CLR)

Copia los elementos de un intervalo de origen a un intervalo de destino salvo los elementos duplicados que son adyacentes entre sí.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función unique_copy de la biblioteca estándar de C++. Para obtener más información, consulte unique_copy.

upper_bound (STL/CLR)

Busca la posición del primer elemento de un intervalo ordenado que tiene un valor mayor que un valor especificado, donde el criterio de ordenación se puede especificar mediante un predicado binario.

Sintaxis

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

Comentarios

Esta función se comporta igual que la función upper_bound de la biblioteca estándar de C++. Para obtener más información, consulte upper_bound.