Sets are a kind of associative containers that stores unique elements, and in which the elements themselves are the keys
Associative containers are containers especially designed to be efficient accessing its elements by their key (unlike sequence containers, which are more efficient accessing elements by their relative or absolute position).
Internally, the elements in a set
are always sorted from lower to higher following a specific strict weak ordering criterion set on container construction.
Sets are typically implemented as binary search trees
Therefore, the main characteristics of set
as an associative container are:
- Unique element values: no two elements in the set can compare equal to each other. For a similar associative container allowing for multiple equivalent elements, see multiset.
- The element value is the key itself. For a similar associative container where elements are accessed using a key, but map to a value different than this key, see map.
- Elements follow a strict weak ordering at all times. Unordered associative arrays, like unordered_set, are available in implementations following TR1.
This container class supports bidirectional iterators
In their implementation in the C++ Standard Template Library, set
containers take three template parameters:
template < class Key, class Compare = less<Key>,
class Allocator = allocator<Key> > class set;
Where the template parameters have the following meanings:
- Key: Key type: type of the elements contained in the container. Each elements in a set is also its key.
- Compare: Comparison class: A class that takes two arguments of the same type as the container elements and returns a bool. The expression comp(a,b), where comp is an object of this comparison class and a and b are elements of the container, shall return true if a is to be placed at an earlier position than b in a strict weak ordering operation. This can either be a class implementing a function call operator or a pointer to a function (see constructor for an example). This defaults to less<Key>, which returns the same as applying the less-than operator (a<b).
The set object uses this expression to determine the position of the elements in the container. All elements in a set container are ordered following this rule at all times.
- Allocator: Type of the allocator object used to define the storage allocation model. By default, the allocator class template for type Key is used, which defines the simplest memory allocation model and is value-independent.
In the reference for the set
member functions, these same names (Key
) are assumed for the template parameters.
|operator=|| Copy container content (public member function)|
|begin|| Return iterator to beginning (public member function)|
|end|| Return iterator to end (public member function)|
|rbegin|| Return reverse iterator to reverse beginning (public member function)|
|rend|| Return reverse iterator to reverse end (public member function)|
|empty|| Test whether container is empty (public member function)|
|size|| Return container size (public member function)|
|max_size|| Return maximum size (public member function)|
|insert|| Insert element (public member function)|
|erase|| Erase elements (public member function)|
|swap|| Swap content (public member function)|
|clear|| Clear content (public member function)|
|key_comp|| Return comparison object (public member function)|
|value_comp|| Return comparison object (public member function)|
|find|| Get iterator to element (public member function)|
|count|| Count elements with a specific key (public member function)|
|lower_bound|| Return iterator to lower bound (public member function)|
|upper_bound|| Return iterator to upper bound (public member function)|
|equal_range|| Get range of equal elements (public member function)|
of template <class Key, class Compare=less<Key>, class Allocator=allocator<Key> > class set;
|const_iterator||Constant bidirectional iterator|
|size_type||Unsigned integral type (usually same as size_t)|
|difference_type||Signed integral type (usually same as ptrdiff_t)|