set_symmetric_difference

Artykuł
06/09/2015

Łączy w sobie wszystkie elementy, które należą do jednego, ale nie obu zakresów źródłowych sortowane do zakresu docelowego pojedynczy, posortowany, gdzie kryterium sortowania może być określona przez predykatu dwuelementowego.

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

Parametry

_First1
Wejściowy sterująca adresowania położenie pierwszego elementu w pierwszym z dwóch zakresów źródłowych posortowane Zjednoczone i posortowane w pojedynczy zakres reprezentujących różnicy symetrycznej dwóch zakresów.
_Last1
Wejściowy iteratora adresowania położenie jednego poza ostatnim elementem w pierwszym dwóch zakresów źródłowych posortowane Zjednoczone i posortowane w pojedynczy zakres reprezentujących różnicy symetrycznej dwóch zakresów.
_First2
Wejściowy iterację adresowania położenie pierwszego elementu w drugim z dwóch kolejnych sortowane zakresów źródłowych Zjednoczone i posortowane w pojedynczy zakres reprezentujących różnicy symetrycznej dwóch zakresów.
_Last2
Wejściowy iterację adresowania ostatnich pozycji, jeden ostatni element w drugim z dwóch kolejnych sortowane zakresów źródłowych Zjednoczone i posortowane w pojedynczy zakres reprezentujących różnicy symetrycznej dwóch zakresów.
**_**Result
Położenie pierwszego elementu w zakresie docelowym, gdzie mają zostać scalone w pojedynczej sortowanym zakresie reprezentujących różnicy symetrycznej dwóch zakresów dwóch zakresów adresowania iterację danych wyjściowych.
_Comp
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest większy niż inny.Predykat binarny przyjmuje dwa argumenty i powinien zwrócić true kiedy pierwszy element jest mniejszy niż drugi element i false w przeciwnym wypadku.

Wartość zwracana

Dane wyjściowe iterację adresowania położenie jeden obok ostatniego elementu w zakresie docelowym posortowane reprezentujących różnicy symetrycznej dwóch zakresów.

Uwagi

Odwołanie do zakresów Yródłowych posortowane musi być prawidłowy; wszystkie wskaźniki muszą być dereferenceable i w ramach każdej sekwencji ostatniej pozycji musi być osiągalny od pierwszego przez incrementation.

Zakres docelowy nie powinien zachodzić albo z zakresów źródłowych i powinien być wystarczająco duży, aby zawierać zakres docelowy.

Zakresów źródłowych posortowane musi każdego uzgodnienia jako warunek wstępny do stosowania korespondencji seryjnej algorytm zgodnie z samej kolejności jak ma być używany przez algorytm sortowania Scalonej zakresów.

Operacja jest stabilna, jak względna kolejność elementów w obrębie każdego zakresu jest zachowywany w zakresie docelowym.Zakresów źródłowych nie są modyfikowane przez algorytm korespondencji seryjnej.

Typy wartości wejściowych Iteratory muszą być mniej-niż porównywalne do zamówione, tak, że biorąc pod uwagę dwa elementy, może zostać stwierdzone, że są one równoważne (w tym sensie, że nie jest mniejsza niż inne) albo że jeden jest mniejsza niż inne.Powoduje porządkowanie między elementami nonequivalent.Gdy istnieją równoważne elementy w obu zakresów źródłowych, elementy w pierwszym zakresie poprzedzać elementy z drugiego zakresu źródłowego w zakresie docelowym.Jeśli zakresów źródłowych zawierają duplikatów elementu, zakres docelowy będzie zawierać wartość bezwzględną liczby wystąpień tych elementów w jednym z zakresów źródłowych przekracza wystąpień tych elementów w drugi zakres źródłowy.

Złożoność algorytm jest liniowy, za co najwyżej 2 * ((_Last1-_First1) – (_Last2-_First2))-1 porównania dla zakresów źródłowych niepuste.

set_symmetric_difference ma dwa powiązane formularze:

Aby uzyskać informacje o zachowaniu tych funkcji, zobacz Zaznaczone iteratory.

Przykład

// 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;
}

Dane wyjściowe

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

Wymagania

Nagłówek: <algorytm>

Przestrzeń nazw: std

Zobacz też

Informacje

Standardowa biblioteka szablonów

Udostępnij za pośrednictwem