Standard C++	Library
 		 Copyright 1996, Rogue Wave Software, Inc.

 NAME

   set_symmetric_difference  - Basic set	operation for sorted sequences.

 SYNOPSIS

   #include <algorithm>

   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 Compare>
   OutputIterator
   set_symmetric_difference (InputIterator1 first1,
 			   InputIterator1 last1,
 			   InputIterator2 first2,
 			   InputIterator2 last2,
 			   OutputIterator result, Compare comp);

 DESCRIPTION

   set_symmetric_difference constructs a	sorted symmetric difference of
   the elements from	the two	ranges.	 This means that the
   constructed range includes copies of the elements that are present
   in the range	[first1, last1) but not present in the	range [first2,
   last2)and copies	of the elements	that are present in
   the	range [first2, last2) but not in the range [first1, last1).
   It returns the end of the constructed range.

   For example, suppose we have two sets:

   1 2 3	4 5

   and

   3 4 5	6 7

   The set_symmetric_difference of these	two sets is:

   1 2 6	7

   The result of	set_symmetric_difference is undefined if the result
   range overlaps with	either of the original ranges.

   set_symmetric_difference assumes that	the ranges are sorted using
   the default comparison operator less than	(<), unless an
   alternative comparison operator (comp) is provided.

   Use the set_symmetric_difference algorithm to	return a result	that
   includes elements that	are present in the first set and not
   in	the second.

 COMPLEXITY

   At most ((last1 - first1) + (last2 - first2))	* 2 -1	comparisons
   are	performed.

 EXAMPLE

   //
   // set_s_di.cpp
   //
    #include<algorithm>
    #include<set>
    #include <istream.h>

   int main()
    {

      //Initialize some sets
     int	a1[] = {1,3,5,7,9,11};
     int	a3[] = {3,5,7,8};
     set<int, less<int> > odd(a1,a1+6), result,
 			 small(a3,a3+4);

      //Create an insert_iterator for result
     insert_iterator<set<int, less<int> > >
 		  res_ins(result, result.begin());

      //Demonstrate set_symmetric_difference
     cout << "The symmetric difference of:" << endl << "{";
     copy(small.begin(),small.end(),
 	 ostream_iterator<int,char>(cout," "));
     cout << "} with {";
     copy(odd.begin(),odd.end(),
 	 ostream_iterator<int,char>(cout," "));
     cout << "} =" << endl << "{";
      set_symmetric_difference(small.begin(), small.end(),
 			odd.begin(), odd.end(),	res_ins);
     copy(result.begin(),result.end(),
 	 ostream_iterator<int,char>(cout," "));
     cout << "}"	<< endl	<< endl;

     return 0;
    }

   Output :
   The symmetric	difference of:
   {3 5 7 8 } with {1 3 5 7 9 11	} =
   {1 8 9 11 }

 WARNING

   If your compiler does	not support default template parameters, then
   you need to always supply	the Compare template argument and the
   Allocator	template	argument. For instance,	you will need
   to write :

   set<int, less<int>, allocator<int> >

   instead of :

   set<int>

 SEE ALSO

   includes, set, set_union, set_intersection, set_difference

 STANDARDS CONFORMANCE
   ANSI X3J16/ISO WG21 Joint C++	Committee