*set:: begin

const_iterator begin() const;iterator begin();

// set_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1;  set <int>::iterator s1_Iter;  set <int>::const_iterator s1_cIter;  s1.insert( 1 );  s1.insert( 2 );  s1.insert( 3 );  s1_Iter = s1.begin( );  cout << "The first element of s1 is " << *s1_Iter << endl;  s1_Iter = s1.begin( );  s1.erase( s1_Iter );  // The following 2 lines would err because the iterator is const  // s1_cIter = s1.begin( );  // s1.erase( s1_cIter );  s1_cIter = s1.begin( );  cout << "The first element of s1 is now " << *s1_cIter << endl;
}  

*set::cbegin

const_iterator cbegin() const;

set::cend

const_iterator cend() const;

*set:: clear

void clear();

// set_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;     set <int> s1;  s1.insert( 1 );  s1.insert( 2 );  cout << "The size of the set is initially " << s1.size( )  << "." << endl;  s1.clear( );  cout << "The size of the set after clearing is "   << s1.size( ) << "." << endl;
}  

set:: const_iterator

typedef implementation-defined const_iterator;  

set:: const_pointer

typedef typename allocator_type::const_pointer const_pointer;  

set:: const_reference

typedef typename allocator_type::const_reference const_reference;  

// set_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1;  s1.insert( 10 );  s1.insert( 20 );  // Declare and initialize a const_reference &Ref1   // to the 1st element  const int &Ref1 = *s1.begin( );  cout << "The first element in the set is "  << Ref1 << "." << endl;  // The following line would cause an error because the   // const_reference cannot be used to modify the set  // Ref1 = Ref1 + 5;
}  

set:: const_reverse_iterator

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;  

*set:: count

size_type count(const Key& key) const;

// set_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main()
{  using namespace std;  set<int> s1;  set<int>::size_type i;  s1.insert(1);  s1.insert(1);  // Keys must be unique in set, so duplicates are ignored  i = s1.count(1);  cout << "The number of elements in s1 with a sort key of 1 is: "  << i << "." << endl;  i = s1.count(2);  cout << "The number of elements in s1 with a sort key of 2 is: "  << i << "." << endl;
}  

set::crbegin

const_reverse_iterator crbegin() const;

// set_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;     set <int> s1;  set <int>::const_reverse_iterator s1_crIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s1_crIter = s1.crbegin( );  cout << "The first element in the reversed set is "  << *s1_crIter << "." << endl;
}  

set::crend

const_reverse_iterator crend() const;

// set_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main() {  using namespace std;     set <int> s1;  set <int>::const_reverse_iterator s1_crIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s1_crIter = s1.crend( );  s1_crIter--;  cout << "The last element in the reversed set is "  << *s1_crIter << "." << endl;
}  

set:: difference_type

typedef typename allocator_type::difference_type difference_type;  

// set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>  int main( )
{  using namespace std;  set <int> s1;  set <int>::iterator s1_Iter, s1_bIter, s1_eIter;  s1.insert( 20 );  s1.insert( 10 );  s1.insert( 20 );   // won't insert as set elements are unique  s1_bIter = s1.begin( );  s1_eIter = s1.end( );  set <int>::difference_type   df_typ5, df_typ10, df_typ20;  df_typ5 = count( s1_bIter, s1_eIter, 5 );  df_typ10 = count( s1_bIter, s1_eIter, 10 );  df_typ20 = count( s1_bIter, s1_eIter, 20 );  // the keys, and hence the elements of a set are unique,  // so there is at most one of a given value  cout << "The number '5' occurs " << df_typ5  << " times in set s1.\n";  cout << "The number '10' occurs " << df_typ10  << " times in set s1.\n";  cout << "The number '20' occurs " << df_typ20  << " times in set s1.\n";  // count the number of elements in a set  set <int>::difference_type  df_count = 0;  s1_Iter = s1.begin( );  while ( s1_Iter != s1_eIter)     {  df_count++;  s1_Iter++;  }  cout << "The number of elements in the set s1 is: "   << df_count << "." << endl;
}  

set::emplace

template <class... Args>
pair<iterator, bool>
emplace(Args&&... args);

set::emplace_hint

template <class... Args>
iterator emplace_hint(const_iterator where,  Args&&... args);

*set:: empty

bool empty() const;

// set_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1, s2;  s1.insert ( 1 );  if ( s1.empty( ) )  cout << "The set s1 is empty." << endl;  else  cout << "The set s1 is not empty." << endl;  if ( s2.empty( ) )  cout << "The set s2 is empty." << endl;  else  cout << "The set s2 is not empty." << endl;
}  

*set:: end

const_iterator end() const;iterator end();

set:: equal_range

pair <const_iterator, const_iterator> equal_range (const Key& key) const;pair <iterator, iterator> equal_range (const Key& key);

// set_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  typedef set<int, less< int > > IntSet;  IntSet s1;  set <int, less< int > > :: const_iterator s1_RcIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;  p1 = s1.equal_range( 20 );  cout << "The upper bound of the element with "  << "a key of 20 in the set s1 is: "  << *(p1.second) << "." << endl;  cout << "The lower bound of the element with "  << "a key of 20 in the set s1 is: "  << *(p1.first) << "." << endl;  // Compare the upper_bound called directly   s1_RcIter = s1.upper_bound( 20 );  cout << "A direct call of upper_bound( 20 ) gives "  << *s1_RcIter << "," << endl  << "matching the 2nd element of the pair"  << " returned by equal_range( 20 )." << endl;  p2 = s1.equal_range( 40 );  // If no match is found for the key,  // both elements of the pair return end( )  if ( ( p2.first == s1.end( ) ) && ( p2.second == s1.end( ) ) )  cout << "The set s1 doesn't have an element "  << "with a key less than 40." << endl;  else  cout << "The element of set s1 with a key >= 40 is: "  << *(p1.first) << "." << endl;
}  

*set:: erase

iterator erase(const_iterator Where);iterator erase(const_iterator First,  const_iterator Last);size_type erase(const key_type& Key);

*set:: find

iterator find(const Key& key);const_iterator find(const Key& key) const;

set:: get_allocator

allocator_type get_allocator() const;

// set_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int>::allocator_type s1_Alloc;  set <int>::allocator_type s2_Alloc;  set <double>::allocator_type s3_Alloc;  set <int>::allocator_type s4_Alloc;  // The following lines declare objects  // that use the default allocator.  set <int> s1;  set <int, allocator<int> > s2;  set <double, allocator<double> > s3;  s1_Alloc = s1.get_allocator( );  s2_Alloc = s2.get_allocator( );  s3_Alloc = s3.get_allocator( );  cout << "The number of integers that can be allocated"  << endl << "before free memory is exhausted: "  << s2.max_size( ) << "." << endl;  cout << "\nThe number of doubles that can be allocated"  << endl << "before free memory is exhausted: "  << s3.max_size( ) <<  "." << endl;  // The following line creates a set s4  // with the allocator of multiset s1.  set <int> s4( less<int>( ), s1_Alloc );  s4_Alloc = s4.get_allocator( );  // Two allocators are interchangeable if  // storage allocated from each can be  // deallocated by the other  if( s1_Alloc == s4_Alloc )  {  cout << "\nThe allocators are interchangeable."  << endl;  }  else  {  cout << "\nThe allocators are not interchangeable."  << endl;  }
}  

*set:: insert

// (1) single element
pair<iterator, bool> insert(const value_type& Val);// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(ValTy&& Val);// (3) single element with hint
iterator insert(const_iterator Where,  const value_type& Val);// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(const_iterator Where,  ValTy&& Val);// (5) range
template <class InputIterator>
void insert(InputIterator First,  InputIterator Last);// (6) initializer list
void insert(initializer_list<value_type>
IList);

*set:: iterator

typedef implementation-defined iterator;  

set:: key_comp

key_compare key_comp() const;

// set_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int, less<int> > s1;  set<int, less<int> >::key_compare kc1 = s1.key_comp( ) ;  bool result1 = kc1( 2, 3 ) ;  if( result1 == true )     {  cout << "kc1( 2,3 ) returns value of true, "  << "where kc1 is the function object of s1."  << endl;  }  else     {  cout << "kc1( 2,3 ) returns value of false "  << "where kc1 is the function object of s1."  << endl;  }  set <int, greater<int> > s2;  set<int, greater<int> >::key_compare kc2 = s2.key_comp( ) ;  bool result2 = kc2( 2, 3 ) ;  if(result2 == true)     {  cout << "kc2( 2,3 ) returns value of true, "  << "where kc2 is the function object of s2."  << endl;  }  else     {  cout << "kc2( 2,3 ) returns value of false, "  << "where kc2 is the function object of s2."  << endl;  }
}  

set:: key_compare

typedef Traits key_compare;  

set:: key_type

typedef Key key_type;  

*set:: lower_bound

const_iterator lower_bound(const Key& key) const;iterator lower_bound(const Key& key);

// set_lower_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1;  set <int> :: const_iterator s1_AcIter, s1_RcIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s1_RcIter = s1.lower_bound( 20 );  cout << "The element of set s1 with a key of 20 is: "  << *s1_RcIter << "." << endl;  s1_RcIter = s1.lower_bound( 40 );  // If no match is found for the key, end( ) is returned  if ( s1_RcIter == s1.end( ) )  cout << "The set s1 doesn't have an element "  << "with a key of 40." << endl;  else  cout << "The element of set s1 with a key of 40 is: "  << *s1_RcIter << "." << endl;  // The element at a specific location in the set can be found   // by using a dereferenced iterator that addresses the location  s1_AcIter = s1.end( );  s1_AcIter--;  s1_RcIter = s1.lower_bound( *s1_AcIter );  cout << "The element of s1 with a key matching "  << "that of the last element is: "  << *s1_RcIter << "." << endl;
}  

set:: max_size

size_type max_size() const;

// set_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;     set <int> s1;  set <int>::size_type i;  i = s1.max_size( );     cout << "The maximum possible length "  << "of the set is " << i << "." << endl;
}  

set::operator =

set& operator=(const set& right);set& operator=(set&& right);

// set_operator_as.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )  {  using namespace std;  set<int> v1, v2, v3;  set<int>::iterator iter;  v1.insert(10);  cout << "v1 = " ;  for (iter = v1.begin(); iter != v1.end(); iter++)  cout << *iter << " ";  cout << endl;  v2 = v1;  cout << "v2 = ";  for (iter = v2.begin(); iter != v2.end(); iter++)  cout << *iter << " ";  cout << endl;  // move v1 into v2  v2.clear();  v2 = move(v1);  cout << "v2 = ";  for (iter = v2.begin(); iter != v2.end(); iter++)  cout << *iter << " ";  cout << endl;  }  

set:: pointer

typedef typename allocator_type::pointer pointer;  

*set:: rbegin

const_reverse_iterator rbegin() const;reverse_iterator rbegin();

// set_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;     set <int> s1;  set <int>::iterator s1_Iter;  set <int>::reverse_iterator s1_rIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s1_rIter = s1.rbegin( );  cout << "The first element in the reversed set is "  << *s1_rIter << "." << endl;  // begin can be used to start an iteration   // throught a set in a forward order  cout << "The set is:";  for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )  cout << " " << *s1_Iter;  cout << endl;  // rbegin can be used to start an iteration   // throught a set in a reverse order  cout << "The reversed set is:";  for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )  cout << " " << *s1_rIter;  cout << endl;  // A set element can be erased by dereferencing to its key   s1_rIter = s1.rbegin( );  s1.erase ( *s1_rIter );  s1_rIter = s1.rbegin( );  cout << "After the erasure, the first element "  << "in the reversed set is "<< *s1_rIter << "." << endl;
}  

set:: reference

typedef typename allocator_type::reference reference;  

// set_reference.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1;  s1.insert( 10 );  s1.insert( 20 );  // Declare and initialize a reference &Ref1 to the 1st element  const int &Ref1 = *s1.begin( );  cout << "The first element in the set is "  << Ref1 << "." << endl;
}  

set:: rend

const_reverse_iterator rend() const;reverse_iterator rend();

// set_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main() {  using namespace std;     set <int> s1;  set <int>::iterator s1_Iter;  set <int>::reverse_iterator s1_rIter;  set <int>::const_reverse_iterator s1_crIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s1_rIter = s1.rend( );  s1_rIter--;  cout << "The last element in the reversed set is "  << *s1_rIter << "." << endl;  // end can be used to terminate an iteration   // throught a set in a forward order  cout << "The set is: ";  for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )  cout << *s1_Iter << " ";  cout << "." << endl;  // rend can be used to terminate an iteration   // throught a set in a reverse order  cout << "The reversed set is: ";  for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )  cout << *s1_rIter << " ";  cout << "." << endl;  s1_rIter = s1.rend( );  s1_rIter--;  s1.erase ( *s1_rIter );  s1_rIter = s1.rend( );  --s1_rIter;  cout << "After the erasure, the last element in the "  << "reversed set is " << *s1_rIter << "." << endl;
}  

*set:: reverse_iterator

typedef std::reverse_iterator<iterator> reverse_iterator;  

set:: set

set();explicit set(const Traits& Comp);set(const Traits& Comp,  const Allocator& Al);set(const set& Right);set(set&& Right);set(initializer_list<Type> IList);set(initializer_list<Type> IList,  const Compare& Comp);set(initializer_list<Type> IList,  const Compare& Comp,   const Allocator& Al);template <class InputIterator>
set(InputIterator First,  InputIterator Last);template <class InputIterator>
set(InputIterator First,  InputIterator Last,  const Traits& Comp);template <class InputIterator>
set(InputIterator First,  InputIterator Last,  const Traits& Comp,  const Allocator& Al);

// set_set.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main()
{  using namespace std;  // Create an empty set s0 of key type integer  set <int> s0;  // Create an empty set s1 with the key comparison  // function of less than, then insert 4 elements  set <int, less<int> > s1;  s1.insert(10);  s1.insert(20);  s1.insert(30);  s1.insert(40);  // Create an empty set s2 with the key comparison  // function of less than, then insert 2 elements  set <int, less<int> > s2;  s2.insert(10);  s2.insert(20);  // Create a set s3 with the   // allocator of set s1  set <int>::allocator_type s1_Alloc;  s1_Alloc = s1.get_allocator();  set <int> s3(less<int>(), s1_Alloc);  s3.insert(30);  // Create a copy, set s4, of set s1  set <int> s4(s1);  // Create a set s5 by copying the range s1[ first,  last)  set <int>::const_iterator s1_bcIter, s1_ecIter;  s1_bcIter = s1.begin();  s1_ecIter = s1.begin();  s1_ecIter++;  s1_ecIter++;  set <int> s5(s1_bcIter, s1_ecIter);  // Create a set s6 by copying the range s4[ first,  last)  // and with the allocator of set s2  set <int>::allocator_type s2_Alloc;  s2_Alloc = s2.get_allocator();  set <int> s6(s4.begin(), ++s4.begin(), less<int>(), s2_Alloc);  cout << "s1 =";  for (auto i : s1)  cout << " " << i;  cout << endl;  cout << "s2 = " << *s2.begin() << " " << *++s2.begin() << endl;  cout << "s3 =";  for (auto i : s3)  cout << " " << i;  cout << endl;  cout << "s4 =";  for (auto i : s4)  cout << " " << i;  cout << endl;  cout << "s5 =";  for (auto i : s5)  cout << " " << i;  cout << endl;  cout << "s6 =";  for (auto i : s6)  cout << " " << i;  cout << endl;  // Create a set by moving s5  set<int> s7(move(s5));  cout << "s7 =";  for (auto i : s7)  cout << " " << i;  cout << endl;  // Create a set with an initializer_list  cout << "s8 =";  set<int> s8{ { 1, 2, 3, 4 } };  for (auto i : s8)  cout << " " << i;  cout << endl;  cout << "s9 =";  set<int> s9{ { 5, 6, 7, 8 }, less<int>() };  for (auto i : s9)  cout << " " << i;  cout << endl;  cout << "s10 =";  set<int> s10{ { 10, 20, 30, 40 }, less<int>(), s9.get_allocator() };  for (auto i : s10)  cout << " " << i;  cout << endl;
}  

*set:: size

size_type size() const;

// set_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1;  set <int> :: size_type i;  s1.insert( 1 );  i = s1.size( );  cout << "The set length is " << i << "." << endl;  s1.insert( 2 );  i = s1.size( );  cout << "The set length is now " << i << "." << endl;
}  

set:: size_type

typedef typename allocator_type::size_type size_type;  

set:: swap

void swap(set<Key, Traits, Allocator>& right);

// set_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1, s2, s3;  set <int>::iterator s1_Iter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s2.insert( 100 );  s2.insert( 200 );  s3.insert( 300 );  cout << "The original set s1 is:";  for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )  cout << " " << *s1_Iter;  cout   << "." << endl;  // This is the member function version of swap  s1.swap( s2 );  cout << "After swapping with s2, list s1 is:";  for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )  cout << " " << *s1_Iter;  cout  << "." << endl;  // This is the specialized template version of swap  swap( s1, s3 );  cout << "After swapping with s3, list s1 is:";  for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )  cout << " " << *s1_Iter;  cout   << "." << endl;
}  

*set:: upper_bound

const_iterator upper_bound(const Key& key) const;iterator upper_bound(const Key& key);

// set_upper_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;     set <int> s1;  set <int> :: const_iterator s1_AcIter, s1_RcIter;  s1.insert( 10 );  s1.insert( 20 );  s1.insert( 30 );  s1_RcIter = s1.upper_bound( 20 );  cout << "The first element of set s1 with a key greater "  << "than 20 is: " << *s1_RcIter << "." << endl;  s1_RcIter = s1.upper_bound( 30 );  // If no match is found for the key, end( ) is returned  if ( s1_RcIter == s1.end( ) )  cout << "The set s1 doesn't have an element "  << "with a key greater than 30." << endl;  else  cout << "The element of set s1 with a key > 40 is: "  << *s1_RcIter << "." << endl;  // The element at a specific location in the set can be found   // by using a dereferenced iterator addressing the location  s1_AcIter = s1.begin( );  s1_RcIter = s1.upper_bound( *s1_AcIter );  cout << "The first element of s1 with a key greater than"  << endl << "that of the initial element of s1 is: "  << *s1_RcIter << "." << endl;
}  

set:: value_comp

value_compare value_comp() const;

// set_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int, less<int> > s1;  set <int, less<int> >::value_compare vc1 = s1.value_comp( );  bool result1 = vc1( 2, 3 );  if( result1 == true )     {  cout << "vc1( 2,3 ) returns value of true, "  << "where vc1 is the function object of s1."  << endl;  }  else     {  cout << "vc1( 2,3 ) returns value of false, "  << "where vc1 is the function object of s1."  << endl;  }  set <int, greater<int> > s2;  set<int, greater<int> >::value_compare vc2 = s2.value_comp( );  bool result2 = vc2( 2, 3 );  if( result2 == true )     {  cout << "vc2( 2,3 ) returns value of true, "  << "where vc2 is the function object of s2."  << endl;  }  else     {  cout << "vc2( 2,3 ) returns value of false, "  << "where vc2 is the function object of s2."  << endl;  }
}  

set:: value_compare

typedef key_compare value_compare;  

set:: value_type

typedef Key value_type;  

// set_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>  int main( )
{  using namespace std;  set <int> s1;  set <int>::iterator s1_Iter;  set <int>::value_type svt_Int;   // Declare value_type  svt_Int = 10;            // Initialize value_type  set <int> :: key_type skt_Int;   // Declare key_type  skt_Int = 20;             // Initialize key_type  s1.insert( svt_Int );         // Insert value into s1  s1.insert( skt_Int );         // Insert key into s1  // A set accepts key_types or value_types as elements  cout << "The set has elements:";  for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++)  cout << " " << *s1_Iter;  cout << "." << endl;
}