Espacios de nombres
Variantes
Acciones

std::set_difference

De cppreference.com
< cpp‎ | algorithm
 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones de secuencia no modificantes
(C++11)(C++11)(C++11)
(C++17)
Operaciones de secuencia modificantes
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de conjuntos (en rangos ordenados)
set_difference
Operaciones de pila
(C++11)
Operaciones mínimo/máximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en el archivo de encabezado <algorithm>
template< class InputIt1, class InputIt2, class OutputIt >

OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,

                         OutputIt d_first );
(1)
template< class InputIt1, class InputIt2,

          class OutputIt, class Compare >
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,

                         OutputIt d_first, Compare comp );
(2)
Copia los elementos de la gama [first1, last1) ordenados que no se encuentran en el intervalo ordenados [first2, last2) al comienzo rango en d_first .
Original:
Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at d_first.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
El rango resultante es también ordenados. La primera versión espera que tanto la entrada como rangos a ser ordenados con operator<, la segunda versión espera que se ordenan con el comp comparación función dada. elementos equivalentes se trataron individualmente , es decir, si algún elemento se encuentra m veces en [first1, last1) y n veces en [first2, last2), se copian en d_first exactamente std::max(m-n, 0) veces. El rango resultante no se puede solapar con cualquiera de los rangos de entrada .
Original:
The resulting range is also sorted. The first version expects both input ranges to be sorted with operator<, the second version expects them to be sorted with the given comparison function comp. Equivalent elements are treated individually, that is, if some element is found m times in [first1, last1) and n times in [first2, last2), it will be copied to d_first exactly std::max(m-n, 0) times. The resulting range cannot overlap with either of the input ranges.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Contenido

[editar] Parámetros

first1, last1 -
la gama de elementos a examinar
Original:
the range of elements to examine
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
first2, last2 -
la gama de elementos a buscar
Original:
the range of elements to search for
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
comp - objeto función de comparación (es decir, un objeto que satisface los requerimientos de Compare) que devuelve ​true si el primer argumento es menor que el segundo.

La signatura de la función de comparación deberá ser equivalente a lo siguiente:

 bool cmp(const Type1 &a, const Type2 &b);

Mientras que la signatura no necesita ser const &, la función no debe modificar los objetos que se le pasaron y debe admitir todos los valores de los tipos (posiblemente const) Type1 y Type2 a pesar de la categoría de valor (por consiguiente, no se permite a Type1 & , ni tampoco a Type1 a menos que para Type1 un movimiento sea equivalente a una copia (desde C++11)).
Los tipos Type1 y Type2 deben ser tales que objetos de tipo InputIt1 y InputIt2 pueden ser desreferenciados y luego convertidos implícitamente a Type1 and Type2 respectively. ​

Requisitos de tipo
-
InputIt1 debe reunir los requerimientos de InputIterator.
-
InputIt2 debe reunir los requerimientos de InputIterator.
-
OutputIt debe reunir los requerimientos de OutputIterator.

[editar] Valor de retorno

Iterator allá del final de la rango construido .
Original:
Iterator past the end of the constructed range.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Complejidad

En la mayoría de las comparaciones 2·(N1+N2-1), donde N1 = std::distance(first1, last1) y N2 = std::distance(first2, last2) .
Original:
At most 2·(N1+N2-1) comparisons, where N1 = std::distance(first1, last1) and N2 = std::distance(first2, last2).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Posible implementación

Primera versión
template<class InputIt1, class InputIt2, class OutputIt>
OutputIt set_difference(InputIt1 first1, InputIt1 last1,
                        InputIt2 first2, InputIt2 last2,
                        OutputIt d_first)
{
    while (first1 != last1) {
        if (first2 == last2) return std::copy(first1, last1, d_first);
 
        if (*first1 < *first2) {
            *d_first++ = *first1++;
        } else {
            if (! (*first2 < *first1)) {
                ++first1;
            }
            ++first2;
        }
    }
    return d_first;
}
Segunda versión
template<class InputIt1, class InputIt2,
         class OutputIt, class Compare>
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,
                         OutputIt d_first, Compare comp)
{
    while (first1 != last1) {
        if (first2 == last2) return std::copy(first1, last1, d_first);
 
        if (comp(*first1, *first2)) {
            *d_first++ = *first1++;
        } else {
            if (!comp(*first2, *first1)) {
                ++first1;
            }
            ++first2;
        }
    }
    return d_first;
}

[editar] Ejemplo

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
 
int main() {
    std::vector<int> v1 {1, 2, 5, 5, 5, 9};
    std::vector<int> v2 {2, 5, 7};
    std::vector<int> diff;
 
    std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), 
                        std::inserter(diff, diff.begin()));
 
    for (auto i : v1) std::cout << i << ' ';
    std::cout << "minus ";
    for (auto i : v2) std::cout << i << ' ';
    std::cout << "is: ";
 
    for (auto i : diff) std::cout << i << ' ';
    std::cout << '\n';
}

Salida:

1 2 5 5 5 9 minus 2 5 7 is: 1 5 5 9

[editar] Ver también

Devuelve true si una secuencia es una subsecuencia de otra.
(plantilla de función) [editar]
Calcula la diferencia simétrica entre dos conjuntos.
(plantilla de función) [editar]