set_symmetric_difference
Unisce tutti gli elementi appartenenti a uno, ma non entrambi, gli intervalli di origine ordinati in un singolo, è ordinato l'intervallo di destinazione, in cui il criterio di ordinamento può essere specificato da un predicato binario.
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
);
Parametri
_First1
Un iteratore di input destinato alla posizione del primo elemento in prima di due stato ordinato gli intervalli di origine da join e ordinare in un unico intervallo che rappresenta la differenza simmetrica dei due intervalli di origine._Last1
Un iteratore di input destinato alla posizione una dopo l'ultimo elemento in prima di due stato ordinato gli intervalli di origine da join e ordinare in un unico intervallo che rappresenta la differenza simmetrica dei due intervalli di origine._First2
Un iteratore di input destinato alla posizione del primo elemento in una seconda di due intervalli di origine ordinate consecutivi da join e ordinare in un unico intervallo che rappresenta la differenza simmetrica dei due intervalli di origine._Last2
Un iteratore di input destinato alla posizione una dopo l'ultimo elemento in una seconda di due intervalli di origine ordinate consecutivi da join e ordinare in un unico intervallo che rappresenta la differenza simmetrica dei due intervalli di origine.risultato di**_**
Un iteratore di output destinato alla posizione del primo elemento nell'intervallo di destinazione in cui i due intervalli di origine devono essere uniti in un unico intervallo ordinato che rappresenta la differenza simmetrica dei due intervalli di origine._Comp
Oggetto definito dall'utente di funzione predicativa in cui viene definito il concetto cui l'elemento è maggiore di.Il predicato binario accetta due argomenti e deve restituire true quando il primo elemento è minore del secondo elemento e false in caso contrario.
Valore restituito
Un iteratore di output destinato alla posizione una dopo l'ultimo elemento nell'intervallo di destinazione ordinato che rappresenta la differenza simmetrica dei due intervalli di origine.
Note
Gli intervalli di origine ordinate fatto riferimento siano validi, tutti i puntatori devono essere dereferenceable e all'interno di ogni sequenza dell'ultima posizione sia raggiungibile da prima dall'aumento.
L'intervallo di destinazione non deve sovrapporsi a uno degli intervalli di origine e deve essere sufficientemente ampio contenere l'intervallo di destinazione.
Gli intervalli di origine e devono entrambi essere disposti in una precondizione all'applicazione dell'algoritmo merge nello stesso ordine di è essere utilizzato dall'algoritmo per ordinare gli intervalli combinati.
L'operazione diventa stabile quando l'ordine degli elementi all'interno di ogni intervallo viene mantenuto nell'intervallo di destinazione.Gli intervalli di origine non vengono modificati dall'unione dell'algoritmo.
I tipi di valore degli iteratori di input devono essere minore di. confrontabile essere ordinatoe, pertanto, specificando due elementi, può essere determinato o che sono equivalenti in quanto non è inferiore all'altro) o che ne è inferiore all'altro.Ciò comporta un ordine tra elementi antivalenti.Quando sono presenti elementi equivalenti in entrambi gli intervalli di origine, gli elementi del primo intervallo precedono gli elementi del secondo intervallo di origine nell'intervallo di destinazione.Se gli intervalli di origine contengono i duplicati di un elemento, pertanto l'intervallo di destinazione conterrà il valore assoluto del numero da cui le occorrenze degli elementi in quello di intervalli di origine supera le occorrenze degli elementi del secondo intervallo di origine.
La complessità dell'algoritmo è lineare con il massimo 2 * (_Last1 (– _First1) a (_Last2 – _First2)) – confronti 1 per intervalli di origine vuoto.
set_symmetric_difference dispone di due form correlati:
Per informazioni su come queste funzioni si comportano, vedere Iteratori verificati.
Esempio
// 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 ).
Requisiti
intestazione: <algorithm>
Spazio dei nomi: deviazione standard