set_intersection() template < class InputIterator1, class InputIterator2, class OutputIterator > OutputIterator set_intersection( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result ); template < class InputIterator1, class InputIterator2, class OutputIterator, class Compare > OutputIterator set_intersection( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp );

set_intersection() constructs a sorted sequence of the elements present in both sequences marked off by [first1,last1) and [first2,last2) For example, given the two sequences {0,1,2,3} and {0,2,4,6}, the set intersection is {0,2} The element is copied from the first sequence The returned OutputIterator addresses one past the last element placed within the container marked off by result The first version assumes that the sequences were sorted using the less than operator of the underlying type; the second version assumes the sequences were sorted using comp

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

set_symmetric_difference() constructs a sorted sequence of the elements that are present in the first container but not present in the second, and those elements present in the second container but not in the first For example, given the two sequences {0,1,2,3} and {0,2,4,6}, the set symmetric difference is {1,3,4,6} The returned OutputIterator addresses one past the last element placed within the container marked off by result The first version assumes that the sequences were sorted using the less than operator of the underlying type; the second version assumes the sequences were sorted using comp

set_union() template < class InputIterator1, class InputIterator2, class OutputIterator > OutputIterator set_union( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,

file:///F|/WinDDK/resources/CPPPrimer/c++primerhtm (1054 / 1065) [2001-3-29 11:32:16]

OutputIterator result ); template < class InputIterator1, class InputIterator2, class OutputIterator, class Compare > OutputIterator set_union( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp );

set_union() constructs a sorted sequence of the element values contained within the two ranges marked off by [first1,last1) and [first2,last2) For example, given the two sequences {0,1,2,3} and {0,2,4,6}, the set union is {0,1,2,3,4,6} If the element is present in both containers, such as 0 and 2 in our example, the element of the first container is copied The returned OutputIterator addresses one past the last element placed within the container marked off by result The first version assumes that the sequences were sorted using the less than operator of the underlying type; the second version assumes the sequences were sorted using comp

#include <algorithm> #include <set> #include <string> #include <iostreamh> /* * generates: set #1 elements: Eeyore Piglet Pooh Tigger set #2 elements: Heffalump Pooh Woozles set_union() elements: Eeyore Heffalump Piglet Pooh Tigger Woozles set_intersection() elements: Pooh set_difference() elements: Eeyore Piglet Tigger set_symmetric_difference() elements: Eeyore Heffalump Piglet Tigger Woozles */ int main() { string str1[] = { "Pooh", "Piglet", "Tigger", "Eeyore" }; string str2[] = { "Pooh", "Heffalump", "Woozles" }; ostream_iterator< string > ofile( cout, " " ); set<string,less<string>,allocator> set1( str1, str1+4 ); set<string,less<string>,allocator> set2( str2, str2+3 ); cout "set #1 elements:\n\t"; copy( set1begin(), set1end(), ofile ); cout "\n\n"; cout "set #2 elements:\n\t"; copy( set2begin(), set2end(), ofile ); cout "\n\n"; set<string,less<string>,allocator> res; set_union( set1begin(), set1end(), set2begin(), set2end(), inserter( res, resbegin() )); cout "set_union() elements:\n\t"; copy( resbegin(), resend(), ofile ); cout "\n\n"; resclear();

file:///F|/WinDDK/resources/CPPPrimer/c++primerhtm (1055 / 1065) [2001-3-29 11:32:16]

set_intersection( set1begin(), set1end(), set2begin(), set2end(), inserter( res, resbegin() )); cout "set_intersection() elements:\n\t"; copy( resbegin(), resend(), ofile ); cout "\n\n"; resclear(); set_difference( set1begin(), set1end(), set2begin(), set2end(), inserter( res, resbegin() )); cout "set_difference() elements:\n\t"; copy( resbegin(), resend(), ofile ); cout "\n\n"; resclear(); set_symmetric_difference( set1begin(), set1end(), set2begin(), set2end(), inserter( res, resbegin() )); cout "set_symmetric_difference() elements:\n\t"; copy( resbegin(), resend(), ofile ); cout "\n\n"; } sort() template< class RandomAccessIterator > void sort( RandomAccessIterator first, RandomAccessIterator last ); template< class RandomAccessIterator, class Compare > void sort( RandomAccessIterator first, RandomAccessIterator last, Compare comp );

sort() reorders the elements in the range marked off by [first, last) in ascending order using the less than operator of the underlying type The second version orders the elements based on comp (To preserve the order of equal elements, use stable_sort() rather than sort()) We do not provide an explicit program illustrating sort() since it is used in many of the other program examples, such as binary_search(), equal_range(), and inplace_merge()

stable_partition() template< class BidirectionalIterator, class Predicate > BidirectionalIterator stable_partition( BidirectionalIterator first, BidirectionalIterator last, Predicate pred );

stable_partition() behaves exactly the same as partition() except that stable_partition() guarantees to preserve the relative order of the elements within the container Here is the same program as executed for partition(), modified to invoke stable_partition():

#include <algorithm> #include <vector> #include <iostreamh> /* * generates:

file:///F|/WinDDK/resources/CPPPrimer/c++primerhtm (1056 / 1065) [2001-3-29 11:32:16]