set


class template
<set>

Set

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:
1
2
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, Compare and Allocator) are assumed for the template parameters.

Member functions



Iterators:


Capacity:


Modifiers:


Observers:


Operations:


Allocator:


Member types

of template <class Key, class Compare=less<Key>, class Allocator=allocator<Key> > class set;

member typedefinition
key_typeKey
value_typeKey
key_compareCompare
value_compareCompare
allocator_typeAllocator
referenceAllocator::reference
const_referenceAllocator::const_reference
iteratorBidirectional iterator
const_iteratorConstant bidirectional iterator
size_typeUnsigned integral type (usually same as size_t)
difference_typeSigned integral type (usually same as ptrdiff_t)
pointerAllocator::pointer
const_pointerAllocator::const_pointer
reverse_iteratorreverse_iterator<iterator>
const_reverse_iteratorreverse_iterator<const_iterator>