set_symmetric_difference

Artykuł
03/26/2013

Ważnym wszystkich elementów, które należą do jednego, ale nie obu zakresów źródłowych posortowane w zakresie przeznaczenia pojedynczy, sortowane, 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 iteratora adresowania położenie pierwszego elementu w pierwszych dwóch zakresów źródłowych sortowane united i posortowane w pojedynczy zakres reprezentujących symetrycznego różnica dwóch zakresów.
_Last1
Wejściowy iterację adresowania położenie jednego ostatni element w przeszłości w pierwszym dwóch zakresów źródłowych sortowane united i posortowane w pojedynczy zakres reprezentujących symetrycznego różnica dwóch zakresów.
_First2
Iterację wprowadzania adresowania położenie pierwszego elementu w drugim z dwóch kolejnych sortowane zakresów źródłowych united i posortowane w pojedynczy zakres reprezentujących symetrycznego różnica dwóch zakresów.
_Last2
Iterację wprowadzania adresowania jednej pozycji ostatnich ostatni element w drugim z dwóch kolejnych sortowane zakresów źródłowych united i posortowane w pojedynczy zakres reprezentujących symetrycznego różnica dwóch zakresów.
**_**Result
Pozycja pierwszego elementu w zakresie przeznaczenia, gdzie mają być scalone w pojedynczy zakres sortowane reprezentujących symetrycznego różnica dwóch zakresów dwóch zakresów adresowania iterację wyjściowego.
_Comp
Obiektu predykatu funkcję zdefiniowaną przez użytkownika, który definiuje znaczeniu, w którym jeden element jest większa niż innym.Predykatu dwuelementowego ma dwa argumenty i powinna zwrócić true , kiedy pierwszy element jest mniejsza niż drugi element i false inaczej.

Wartość zwracana

Położenie jednej w przeszłości ostatni element w zakresie docelowym sortowane reprezentujących symetrycznego różnica dwóch zakresów adresowania iterację wyjściowego.

Uwagi

Sortowane zakresów odwołania musi być ważny; wszystkie wskaźniki muszą być dereferenceable i w każdej sekwencji ostatniej pozycji musi być osiągalny od pierwszego przez incrementation.

Zakres docelowy nie powinien zachodzić albo zakresów źródłowych i powinna być wystarczająco duża, zawierać zakresu docelowego.

Zakresów źródłowych sortowane musi być ustawione jako warunek zastosowania seryjna jest algorytm zgodnie z tym samym zamawiania jako stosowaną przez algorytm sortowania Scalonej zakresów.

Operacja jest stabilna 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 Iteratory wejściowe muszą być mniej-niż porównywalne zamawiać tak, że biorąc pod uwagę dwa elementy, można ustalić są równoważne (w tym sensie, że nie jest mniejsza niż drugi) albo jednym jest mniejsza niż inne.Powoduje porządkowanie między elementami nonequivalent.Podczas obu zakresów źródłowych są równoważne elementy, elementy w pierwszym zakresie poprzedzać elementy z drugiego zakresu źródłowego w zakresie docelowym.Jeśli zakresów źródłowych zawiera duplikaty elementu, zakres docelowy zawiera wartość bezwzględna liczby przekracza wystąpienia tych elementów w drugi zakres źródłowy w wystąpienia tych elementów w jeden z zakresów źródłowych.

Złożoność algorytm jest liniowa z co najwyżej 2 * ((_Last1 — _First1) – (_Last2 – _First2)) – 1 porównania dla zakresów źródłowych niepusty.

set_symmetric_differencema dwa powiązane formularze:

Informacji na temat zachowania tych funkcji, zobacz Iteratory zaznaczone.

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: <algorithm>

Obszar nazw: std

Zobacz też

Informacje

Standardowa biblioteka szablonu

Udostępnij za pośrednictwem