|
Multiple-key map
Maps are a kind of associative container that stores elements formed by the combination of a key value and a mapped value, much like map containers, but allowing different elements to have the same key value.
In their implementation in the C++ Standard Template Library, multimap containers take four template parameters:
1
2
|
template < class Key, class T, class Compare = less<Key>,
class Allocator = allocator<pair<const Key,T> > > class multimap;
|
Where the template parameters have the following meanings:
- Key: Type of the key values. Each element in a multimap is generally identified by its key value, although multiple elements can have the same key value.
- T: Type of the mapped value. Each element in a multimap is used to store some data as its mapped value.
- Compare: Comparison class: A class that takes two arguments of the key type and returns a bool. The expression comp(a,b), where comp is an object of this comparison class and a and b are key values, 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 multimap object uses this expression to determine the position of the elements in the container. All elements in a multimap 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 is used, which defines the simplest memory allocation model and is value-independent.
In the reference for the multimap member functions, these same names (Key, T, Compare and Allocator) are assumed for the template parameters.
The multimap class template is defined in header map.
See the description of its sibling map class template for more info.
Member functions
| operator= | Copy container content (public member function) |
Iterators:
| 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) |
Capacity:
| empty | Test whether container is empty (public member function) |
| size | Return container size (public member function) |
| max_size | Return maximum size (public member function) |
Modifiers:
| insert | Insert element (public member function) |
| erase | Erase elements (public member function) |
| swap | Swap content (public member function) |
| clear | Clear content (public member function) |
Observers:
| key_comp | Return key comparison object (public member function) |
| value_comp | Return value comparison object (public member function) |
Operations:
| 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) |
Allocator:
Member types
of template <class Key, class T, class Compare=less<Key>, class Allocator=allocator<pair <const Key, T> > > class multimap;
| member type | definition |
|---|
| key_type | Key |
| mapped_type | T |
| value_type | pair<const Key,T> |
| key_compare | Compare |
| value_compare | Nested class to compare elements (see member function value_comp) |
| allocator_type | Allocator |
| reference | Allocator::reference |
| const_reference | Allocator::const_reference |
| iterator | Bidirectional iterator |
| 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) |
| pointer | Allocator::pointer |
| const_pointer | Allocator::const_pointer |
| reverse_iterator | reverse_iterator<iterator> |
| const_reverse_iterator | reverse_iterator<const_iterator> |
|