map<Key, Data, Compare, Alloc>


Category: containers	Component type: type

Description

Map is a Sorted Associative Container that associates objects of type Key with objects of type Data. Map is a Pair Associative Container, meaning that its value type is pair<const Key, Data>. It is also a Unique Associative Container, meaning that no two elements have the same key.

Map has the important property that inserting a new element into a map does not invalidate iterators that point to existing elements. Erasing an element from a map also does not invalidate any iterators, except, of course, for iterators that actually point to the element that is being erased.

Example

struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};

int main()
{
  map<const char*, int, ltstr> months;
  
  months["january"] = 31;
  months["february"] = 28;
  months["march"] = 31;
  months["april"] = 30;
  months["may"] = 31;
  months["june"] = 30;
  months["july"] = 31;
  months["august"] = 31;
  months["september"] = 30;
  months["october"] = 31;
  months["november"] = 30;
  months["december"] = 31;
  
  cout << "june -> " << months["june"] << endl;
  map<const char*, int, ltstr>::iterator cur  = months.find("june");
  map<const char*, int, ltstr>::iterator prev = cur;
  map<const char*, int, ltstr>::iterator next = cur;    
  ++next;
  --prev;
  cout << "Previous (in alphabetical order) is " << (*prev).first << endl;
  cout << "Next (in alphabetical order) is " << (*next).first << endl;
}

Definition

Defined in the standard header map, and in the nonstandard backward-compatibility header map.h.

Template parameters

Parameter	Description	Default
`Key`	The map's key type. This is also defined as `map::key_type`.
`Data`	The map's data type. This is also defined as `map::data_type`.
`Compare`	The key comparison function, a Strict Weak Ordering whose argument type is `key_type`; it returns `true` if its first argument is less than its second argument, and `false` otherwise. This is also defined as `map::key_compare`.	`less<Key>`
`Alloc`	The `map`'s allocator, used for all internal memory management.	`alloc`

Model of

Unique Sorted Associative Container, Pair Associative Container

Type requirements

Data is Assignable.
Compare is a Strict Weak Ordering whose argument type is Key.
Alloc is an Allocator.

Public base classes

None.

Members

Member	Where defined	Description
`key_type`	Associative Container	The `map`'s key type, `Key`.
`data_type`	Pair Associative Container	The type of object associated with the keys.
`value_type`	Pair Associative Container	The type of object, `pair<const key_type, data_type>`, stored in the map.
`key_compare`	Sorted Associative Container	Function object that compares two keys for ordering.
`value_compare`	Sorted Associative Container	Function object that compares two values for ordering.
`pointer`	Container	Pointer to `T`.
`reference`	Container	Reference to `T`
`const_reference`	Container	Const reference to `T`
`size_type`	Container	An unsigned integral type.
`difference_type`	Container	A signed integral type.
`iterator`	Container	Iterator used to iterate through a `map`. [1]
`const_iterator`	Container	Const iterator used to iterate through a `map`.
`reverse_iterator`	Reversible Container	Iterator used to iterate backwards through a `map`. [1]
`const_reverse_iterator`	Reversible Container	Const iterator used to iterate backwards through a `map`.
`iterator begin()`	Container	Returns an `iterator` pointing to the beginning of the `map`.
`iterator end()`	Container	Returns an `iterator` pointing to the end of the `map`.
`const_iterator begin() const`	Container	Returns a `const_iterator` pointing to the beginning of the `map`.
`const_iterator end() const`	Container	Returns a `const_iterator` pointing to the end of the `map`.
`reverse_iterator rbegin()`	Reversible Container	Returns a `reverse_iterator` pointing to the beginning of the reversed map.
`reverse_iterator rend()`	Reversible Container	Returns a `reverse_iterator` pointing to the end of the reversed map.
`const_reverse_iterator rbegin() const`	Reversible Container	Returns a `const_reverse_iterator` pointing to the beginning of the reversed map.
`const_reverse_iterator rend() const`	Reversible Container	Returns a `const_reverse_iterator` pointing to the end of the reversed map.
`size_type size() const`	Container	Returns the size of the `map`.
`size_type max_size() const`	Container	Returns the largest possible size of the `map`.
`bool empty() const`	Container	`true` if the `map`'s size is `0`.
`key_compare key_comp() const`	Sorted Associative Container	Returns the `key_compare` object used by the `map`.
`value_compare value_comp() const`	Sorted Associative Container	Returns the `value_compare` object used by the `map`.
`map()`	Container	Creates an empty `map`.
`map(const key_compare& comp)`	Sorted Associative Container	Creates an empty `map`, using `comp` as the `key_compare` object.
template <class InputIterator> map(InputIterator f, InputIterator l) [2]	Unique Sorted Associative Container	Creates a map with a copy of a range.
template <class InputIterator> map(InputIterator f, InputIterator l, const key_compare& comp) [2]	Unique Sorted Associative Container	Creates a map with a copy of a range, using `comp` as the `key_compare` object.
`map(const map&)`	Container	The copy constructor.
`map& operator=(const map&)`	Container	The assignment operator
`void swap(map&)`	Container	Swaps the contents of two maps.
pair<iterator, bool> insert(const value_type& x)	Unique Associative Container	Inserts `x` into the `map`.
iterator insert(iterator pos, const value_type& x)	Unique Sorted Associative Container	Inserts `x` into the `map`, using `pos` as a hint to where it will be inserted.
template <class InputIterator> void insert(InputIterator, InputIterator) [2]	Unique Sorted Associative Container	Inserts a range into the `map`.
`void erase(iterator pos)`	Associative Container	Erases the element pointed to by `pos`.
`size_type erase(const key_type& k)`	Associative Container	Erases the element whose key is `k`.
`void erase(iterator first, iterator last)`	Associative Container	Erases all elements in a range.
`void clear()`	Associative Container	Erases all of the elements.
`iterator find(const key_type& k)`	Associative Container	Finds an element whose key is `k`.
`const_iterator find(const key_type& k) const`	Associative Container	Finds an element whose key is `k`.
`size_type count(const key_type& k)`	Unique Associative Container	Counts the number of elements whose key is `k`.
`iterator lower_bound(const key_type& k)`	Sorted Associative Container	Finds the first element whose key is not less than `k`.
`const_iterator lower_bound(const key_type& k) const`	Sorted Associative Container	Finds the first element whose key is not less than `k`.
`iterator upper_bound(const key_type& k)`	Sorted Associative Container	Finds the first element whose key greater than `k`.
`const_iterator upper_bound(const key_type& k) const`	Sorted Associative Container	Finds the first element whose key greater than `k`.
pair<iterator, iterator> eq