cppreference.com > C++ Sets begin Syntax:
      #include <set>
      iterator begin();
      const_iterator begin() const;
The function begin() returns an iterator to the first element of the set. begin() should run in constant time. For example, the following code uses begin() to initialize an iterator that is used to traverse a list:
       // Create a list of characters
       list<char> charList;
       for( int i=0; i < 10; i++ ) {
         charList.push_front( i + 65 );
       }
       // Display the list
       list<char>::iterator theIterator;
       for( theIterator = charList.begin(); theIterator != charList.end(); theIterator++ ) {
         cout << *theIterator;
       }
Related topics: end rbegin rend

equal_range
Syntax:

      #include <set>
      pair<iterator, iterator> equal_range( const key_type& key );

The function equal_range() returns two iterators - one to the first element that contains key, another to a point just after the last element that contains key.

clear
Syntax:

      #include <set>
      void clear();

The function clear() deletes all of the elements in the set. clear() runs in linear time.

Related topics:
(C++ Lists) erase

count
Syntax:

      #include <set>
      size_type count( const key_type& key );

The function count() returns the number of occurrences of key in the set.

count() should run in logarithmic time.

empty
Syntax:

      #include <set>
      bool empty() const;

The empty() function returns true if the set has no elements, false otherwise.

For example, the following code uses empty() as the stopping condition on a (C/C++ Keywords) while loop to clear a set and display its contents in reverse order:

     vector<int> v;
     for( int i = 0; i < 5; i++ ) {
       v.push_back(i);
     }
     while( !v.empty() ) {
       cout << v.back() << endl;
       v.pop_back();
     }

Related topics:
size

Container constructors & destructors
Syntax:

      #include <set>
      container();
      container( const container& c );
      ~container();

Every set has a default constructor, copy constructor, and destructor.

The default constructor takes no arguments, creates a new instance of that set, and runs in constant time. The default copy constructor runs in linear time and can be used to create a new set that is a copy of the given set c.

The default destructor is called when the set should be destroyed.

For example, the following code creates a pointer to a vector of integers and then uses the default set constructor to allocate a memory for a new vector:

     vector<int>* v;
     v = new vector<int>();

Related topics:
(C++ Strings) resize

Container operators
Syntax:

      #include <set>
      container operator=(const container& c2);
      bool operator==(const container& c1, const container& c2);
      bool operator!=(const container& c1, const container& c2);
      bool operator<(const container& c1, const container& c2);
      bool operator>(const container& c1, const container& c2);
      bool operator<=(const container& c1, const container& c2);
      bool operator>=(const container& c1, const container& c2);

All of the C++ containers can be compared and assigned with the standard comparison operators: ==, !=, <=, >=, <, >, and =. Performing a comparison or assigning one set to another takes linear time.

Two sets are equal if:

1. Their size is the same, and
2. Each member in location i in one set is equal to the the member in location i in the other set.

Comparisons among sets are done lexicographically.

Related topics:
(C++ Strings) String operators
(C++ Strings) at
(C++ Lists) merge
(C++ Lists) unique

end
Syntax:

      #include <set>
      iterator end();
      const_iterator end() const;

The end() function returns an iterator just past the end of the set.

Note that before you can access the last element of the set using an iterator that you get from a call to end(), you'll have to decrement the iterator first.

For example, the following code uses begin() and end() to iterate through all of the members of a vector:

     vector<int> v1( 5, 789 );
     vector<int>::iterator it;
     for( it = v1.begin(); it != v1.end(); it++ ) {
       cout << *it << endl;
     }

The iterator is initialized with a call to begin(). After the body of the loop has been executed, the iterator is incremented and tested to see if it is equal to the result of calling end(). Since end() returns an iterator pointing to an element just after the last element of the vector, the loop will only stop once all of the elements of the vector have been displayed.

end() runs in constant time.

Related topics:
begin
rbegin
rend

key_comp
Syntax:

      #include <set>
      key_compare key_comp() const;

The function key_comp() returns the function that compares keys.

key_comp() runs in constant time.

Related topics:
value_comp

erase
Syntax:

      #include <set>
      void erase( iterator pos );
      void erase( iterator start, iterator end );
      size_type erase( const key_type& key );

The erase function() either erases the element at pos, erases the elements between start and end, or erases all elements that have the value of key.

find
Syntax:

      #include <set>
      iterator find( const key_type& key );

The find() function returns an iterator to key, or an iterator to the end of the set if key is not found.

find() runs in logarithmic time.

insert
Syntax:

      #include <set>
      iterator insert( iterator i, const TYPE& val );
      void insert( input_iterator start, input_iterator end );
      pair<iterator,bool> insert( const TYPE& val );

The function insert() either:

- inserts val after the element at pos (where pos is really just a suggestion as to where val should go, since sets and maps are ordered), and returns an iterator to that element.
- inserts a range of elements from start to end.
- inserts val, but only if val doesn't already exist. The return value is an iterator to the element inserted, and a boolean describing whether an insertion took place.

Related topics:
(C++ Maps) Map operators

lower_bound
Syntax:

      #include <set>
      iterator lower_bound( const key_type& key );

The lower_bound() function returns an iterator to the first element which has a value greater than or equal to key.

lower_bound() runs in logarithmic time.

Related topics:
upper_bound

max_size
Syntax:

      #include <set>
      size_type max_size() const;

The max_size() function returns the maximum number of elements that the set can hold. The max_size() function should not be confused with the size() or (C++ Strings) capacity() functions, which return the number of elements currently in the set and the the number of elements that the set will be able to hold before more memory will have to be allocated, respectively.

Related topics:
size

rbegin
Syntax:

      #include <set>
      reverse_iterator rbegin();
      const_reverse_iterator rbegin() const;

The rbegin() function returns a reverse_iterator to the end of the current set.

rbegin() runs in constant time.

Related topics:
begin
end
rend

rend
Syntax:

      #include <set>
      reverse_iterator rend();
      const_reverse_iterator rend() const;

The function rend() returns a reverse_iterator to the beginning of the current set.

rend() runs in constant time.

Related topics:
begin
end
rbegin

size
Syntax:

      #include <set>
      size_type size() const;

The size() function returns the number of elements in the current set.

Related topics:
(C++ Strings) capacity
empty
(C++ Strings) length
max_size
(C++ Strings) resize

swap
Syntax:

      #include <set>
      void swap( const container& from );

The swap() function exchanges the elements of the current set with those of from. This function operates in constant time.

For example, the following code uses the swap() function to exchange the values of two strings:

       string first( "This comes first" );
       string second( "And this is second" );
       first.swap( second );
       cout << first << endl;
       cout << second << endl;

The above code displays:

       And this is second
       This comes first

Related topics:
(C++ Lists) splice

upper_bound
Syntax:

      #include <set>
      iterator upper_bound( const key_type& key );

The function upper_bound() returns an iterator to the first element in the set with a key greater than key.

Related topics:
lower_bound

value_comp
Syntax:

      #include <set>
      value_compare value_comp() const;

The value_comp() function returns the function that compares values.

value_comp() runs in constant time.

Related topics:
key_comp