set_symmetric_difference
Une todos los elementos que pertenecen a uno, pero no ambos, intervalos de origen ordenados en un único, ajusta el intervalo de destino, donde el criterio de ordenación se puede especificar por un predicado binario.
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_symmetric_difference(
InputIterator1 _First1,
InputIterator1 _Last1,
InputIterator2 _First2,
InputIterator2 _Last2,
OutputIterator _Result
);
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
OutputIterator set_symmetric_difference(
InputIterator1 _First1,
InputIterator1 _Last1,
InputIterator2 _First2,
InputIterator2 _Last2,
OutputIterator _Result,
BinaryPredicate _Comp
);
Parámetros
_First1
Un iterador de entrada que dirige la posición del primer elemento de la primera de dos intervalos de origen ordenados que se unirán y en un único intervalo que representa la diferencia simétrica de los dos intervalos de origen._Last1
Un iterador de entrada que dirige la posición una más allá del último elemento de la primera de dos intervalos de origen ordenados que se unirán y en un único intervalo que representa la diferencia simétrica de los dos intervalos de origen._First2
Un iterador de entrada que dirige la posición del primer elemento de la segunda de dos intervalos de origen ordenados consecutivos que se unirán y en un único intervalo que representa la diferencia simétrica de los dos intervalos de origen._Last2
Un iterador de entrada que dirige la posición una más allá del último elemento de la segunda de dos intervalos de origen ordenados consecutivos que se unirán y en un único intervalo que representa la diferencia simétrica de los dos intervalos de origen.resultado de**_**
Un iterador de salida que dirige la posición del primer elemento del intervalo de destino donde se unida los dos intervalos de origen en un único intervalo ordenado que representa la diferencia simétrica de los dos intervalos de origen._Comp
Objeto definido por el usuario de la función de predicado en el que define el sentido que un elemento es mayor que otro.El predicado binario toma dos argumentos y debe devolver TRUE cuando el primer elemento es menor que el segundo elemento y Falso de otra manera.
Valor devuelto
Un iterador de salida que dirige la posición una más allá del último elemento del intervalo de destino ordenado que representa la diferencia simétrica de los dos intervalos de origen.
Comentarios
Los intervalos de origen ordenados hace referencia deben ser válidos; todos los punteros deben ser dereferenceable y dentro de cada secuencia la posición última debe ser accesible de primera por el aumento.
El intervalo de destino no debe superponer ninguno de los intervalos de origen y debe ser lo bastante grande para contener el rango de destino.
Los intervalos de origen ordenados deben cada organizar mientras una condición previa a la aplicación del algoritmo de combinación de acuerdo con el mismo de ordenación que es utilizar el algoritmo para ordenar los intervalos combinados.
La operación es estable como el orden relativo de elementos dentro de cada intervalo se conserva en el rango de destino.Los intervalos de origen no son modificados por la combinación del algoritmo.
Los tipos de valor de iteradores de entrada es necesario que comparable ser secuenciado, para, dadas dos elementos, poder determinar las que son equivalentes (en el sentido de que ninguno es menor que otro) o que uno es menor que otro.Esto produce el orden entre los elementos distintos.Cuando hay elementos equivalentes en ambos intervalos de origen, los elementos del primer intervalo preceden a los elementos del intervalo de segundo origen en el rango de destino.Si los intervalos de origen contienen duplicados de un elemento, el intervalo de destino contendrá el valor absoluto del número por el que las apariciones de los elementos del de los intervalos de origen superan las apariciones de los elementos del intervalo de segundo origen.
La complejidad del algoritmo es lineal con como máximo 2 * ((_Last1 – _First1) – (_Last2 – _First2)) – las comparaciones 1 para los intervalos de origen no vacíos.
set_symmetric_difference tiene dos formularios relacionados:
Para obtener información sobre cómo estas funciones se comportan, vea Iteradores comprobados.
Ejemplo
// alg_set_sym_diff.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional> // For greater<int>( )
#include <iostream>
// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser (int elem1, int elem2 )
{
if ( elem1 < 0 )
elem1 = - elem1;
if ( elem2 < 0 )
elem2 = - elem2;
return elem1 < elem2;
}
int main( )
{
using namespace std;
vector <int> v1a, v1b, v1 ( 12 );
vector <int>::iterator Iter1a, Iter1b, Iter1, Result1;
// Constructing vectors v1a & v1b with default less-than ordering
int i;
for ( i = -1 ; i <= 4 ; i++ )
{
v1a.push_back( i );
}
int ii;
for ( ii =-3 ; ii <= 0 ; ii++ )
{
v1b.push_back( ii );
}
cout << "Original vector v1a with range sorted by the\n "
<< "binary predicate less than is v1a = ( " ;
for ( Iter1a = v1a.begin( ) ; Iter1a != v1a.end( ) ; Iter1a++ )
cout << *Iter1a << " ";
cout << ")." << endl;
cout << "Original vector v1b with range sorted by the\n "
<< "binary predicate less than is v1b = ( " ;
for ( Iter1b = v1b.begin ( ) ; Iter1b != v1b.end ( ) ; Iter1b++ )
cout << *Iter1b << " ";
cout << ")." << endl;
// Constructing vectors v2a & v2b with ranges sorted by greater
vector <int> v2a ( v1a ) , v2b ( v1b ) , v2 ( v1 );
vector <int>::iterator Iter2a, Iter2b, Iter2, Result2;
sort ( v2a.begin ( ) , v2a.end ( ) , greater<int> ( ) );
sort ( v2b.begin ( ) , v2b.end ( ) , greater<int> ( ) );
cout << "Original vector v2a with range sorted by the\n "
<< "binary predicate greater is v2a = ( " ;
for ( Iter2a = v2a.begin ( ) ; Iter2a != v2a.end ( ) ; Iter2a++ )
cout << *Iter2a << " ";
cout << ")." << endl;
cout << "Original vector v2b with range sorted by the\n "
<< "binary predicate greater is v2b = ( " ;
for ( Iter2b = v2b.begin ( ) ; Iter2b != v2b.end ( ) ; Iter2b++ )
cout << *Iter2b << " ";
cout << ")." << endl;
// Constructing vectors v3a & v3b with ranges sorted by mod_lesser
vector <int> v3a ( v1a ), v3b ( v1b ) , v3 ( v1 );
vector <int>::iterator Iter3a, Iter3b, Iter3, Result3;
sort ( v3a.begin ( ) , v3a.end ( ) , mod_lesser );
sort ( v3b.begin ( ) , v3b.end ( ) , mod_lesser );
cout << "Original vector v3a with range sorted by the\n "
<< "binary predicate mod_lesser is v3a = ( " ;
for ( Iter3a = v3a.begin ( ) ; Iter3a != v3a.end ( ) ; Iter3a++ )
cout << *Iter3a << " ";
cout << ")." << endl;
cout << "Original vector v3b with range sorted by the\n "
<< "binary predicate mod_lesser is v3b = ( " ;
for ( Iter3b = v3b.begin ( ) ; Iter3b != v3b.end ( ) ; Iter3b++ )
cout << *Iter3b << " ";
cout << ")." << endl;
// To combine into a symmetric difference in ascending
// order with the default binary predicate less <int> ( )
Result1 = set_symmetric_difference ( v1a.begin ( ) , v1a.end ( ) ,
v1b.begin ( ) , v1b.end ( ) , v1.begin ( ) );
cout << "Set_symmetric_difference of source ranges with default order,"
<< "\n vector v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != Result1 ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// To combine into a symmetric difference in descending
// order, specify binary predicate greater<int>( )
Result2 = set_symmetric_difference ( v2a.begin ( ) , v2a.end ( ) ,
v2b.begin ( ) , v2b.end ( ) ,v2.begin ( ) , greater <int> ( ) );
cout << "Set_symmetric_difference of source ranges with binary"
<< "predicate greater specified,\n vector v2mod = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != Result2 ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// To combine into a symmetric difference applying a user
// defined binary predicate mod_lesser
Result3 = set_symmetric_difference ( v3a.begin ( ) , v3a.end ( ) ,
v3b.begin ( ) , v3b.end ( ) , v3.begin ( ) , mod_lesser );
cout << "Set_symmetric_difference of source ranges with binary "
<< "predicate mod_lesser specified,\n vector v3mod = ( " ; ;
for ( Iter3 = v3.begin( ) ; Iter3 != Result3 ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
Output
Original vector v1a with range sorted by the
binary predicate less than is v1a = ( -1 0 1 2 3 4 ).
Original vector v1b with range sorted by the
binary predicate less than is v1b = ( -3 -2 -1 0 ).
Original vector v2a with range sorted by the
binary predicate greater is v2a = ( 4 3 2 1 0 -1 ).
Original vector v2b with range sorted by the
binary predicate greater is v2b = ( 0 -1 -2 -3 ).
Original vector v3a with range sorted by the
binary predicate mod_lesser is v3a = ( 0 -1 1 2 3 4 ).
Original vector v3b with range sorted by the
binary predicate mod_lesser is v3b = ( 0 -1 -2 -3 ).
Set_symmetric_difference of source ranges with default order,
vector v1mod = ( -3 -2 1 2 3 4 ).
Set_symmetric_difference of source ranges with binarypredicate greater specified,
vector v2mod = ( 4 3 2 1 -2 -3 ).
Set_symmetric_difference of source ranges with binary predicate mod_lesser specified,
vector v3mod = ( 1 4 ).
Requisitos
encabezado: <algoritmo>
espacio de nombres: std