• http://facebook.com/
• https://www.google.com/accounts/o8/id
• https://me.yahoo.com

# Map

Map and multimap containers are containers that manage key/value pairs as elements.

## Definition

The map template is defined in the standard header <map>, and in the nonstandard backward-compatibility header <map.h>.
```#include <map>
namespace std {
template < class Key, class T,
class Compare = less<Key>,
class Allocator = allocator<pair<const Key,T> > >
class map;
}```

## Description

The map template associates, or maps, values of some key type to values of some other type. For example, it is possible to use a map to associate names represented as strings with some other type that you chose, such as floating-point values. This would allow you to associate a person's name with a bank account balance, grade point average, etc.

The main characteristics of a map are:

• each element has an unique key
• each element is composed of a key and a mapped value
• elements follow a strict weak ordering

A strict weak ordering is a binary relation on a set that is a strict partial order (a transitive relation that is irreflexive, or equivalently, that is asymmetric) in which the relation "neither nor " is transitive.

A short example declaring a map is:
`map<string, double> aMap; // associates strings with doubles`

## Performance

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.

The asymptotic complexity of the operations that can be applied to maps are as follows:

Operation Complexity
Searching for an element O(log n)
Inserting a new element O(log n)
Incrementing/decrementing an iterator O(log n)
Removing a single map element O(log n)
Copying an entire map O(n)
Iterating through all elements O(n)

There is also a multimap container class where the keys do not have to be unique (a key can be associated with more than one value).

## Map Operations

Create, Copy, and Destroy Operations
Operation Effect
map m Creates an empty map without any elements
map m(op) Creates an empty map that uses op as the sorting criterion
map m1(m2) Creates a copy of another map of the same type (all elements are copied)
map m(beg,end) Creates a map initialized by the elements of the range [beg,end)
map m(beg,end,op) Creates a map with the sorting criterion op initialized by the elements of the range [beg,end)
m.~map() Destroys all elements and frees the memory

Map Effect
map< Key,el > A map that sorts keys with `less<>` (operator `<`)
map< Key,el,op > A map that sorts keys with op

Nonmodifying Operations of Maps
Operation Effect
m.size() Returns the actual number of elements in the container
m.empty() Returns if the container is empty (equivalent to size()==0)
m.max_size() Returns the maximum number of elements possible
m1==m2 Returns if m1 is equal to m2
m1!=m2 Returns if m1 is not equal to m2 (equivalent to !(m1==m2))
m1<m2 Returns if m1 is less than m2
m1>m2 Returns if m1 is greater than m2 (equivalent to m2<m1)
m1<=m2 Returns if m1 is less than or equal to m2 (equivalent to !(m2<m1))
m1>=m2 Returns if m1 is greater than or equal to m2 (equivalent to !(m1<m2))

Note: Operator [ ] (m[key]) returns a reference to the component of m whose key value is key, if this component exists. If this component does not exist, inserts a new component into m, the value of whose key is key, and for which the corresponding value is the default value of type el.

Special Search Operations of Maps
Operation Effect
count(key) Returns the number of elements with key key
find(key) Returns the position of the first element with key key or end()
lower_bound(key) Returns the first position where an element with key key would get inserted (the first element with key >= key)
upper_bound(key) Returns the last position where an element with key key would get inserted (the first element with key > key)
equal_range(key) Returns the first and last positions where elements with key key would get inserted (the range of elements with key == key)

Assignment Operations of Maps
Operation Effect
m1=m2 Assigns all elements of m2 to m1
m1.swap(m2) Swaps the data of m1 and m2
swap(m1,m2) Same (as global function)

Iterator Operations of Maps
Operation Effect
m.begin() Returns a bidirectional iterator for the first element (keys are considered `const`)
m.end() Returns a bidirectional iterator for the position after the last element (keys are considered `const`)
m.rbegin() Returns a reverse iterator for the first element of a reverse iteration
m.rend() Returns a reverse iterator for the position after the last element of a reverse iteration

Inserting and Removing Elements of Maps
Operation Effect
m.insert(elem) Inserts a copy of elem and returns the position of the new element and, for maps, if it succeeded
m.insert(pos,elem) Inserts a copy of elem and returns the position of the new element (pos is used as a hint pointing to where the insert should start the search)
m.insert(beg,end) Inserts a copy of all elements of the range [beg,end)(returns nothing)
m.erase(elem) Removes all elements with value elem and returns the number of removed elements
m.erase(pos) Removes the element at iterator position pos (returns nothing)
m.erase(beg,end) Removes all elements of the range [beg,end)(returns nothing)
m.clear() Removes all elements

### References:

Example:
##### Example - accessing values of a map
Problem
This example of program creates an empty map, places three key/value pairs into it, then displays the values by accessing them via their keys.
Workings
```#include <iostream>
#include <map>

using namespace std;

int main()
{
map<char, int> m;
if (m.empty())
cout << "\nThe created map is currently empty.";

m['x'] = 1;
m['y'] = 2;
m['z'] = 3;

cout << "\nAfter entering the three key/value pairs, the size of the map is now " << m.size();
cout << "\nIf the component key is x, the component value is "<< m['x'];
cout << "\nIf the component key is y, the component value is "<< m['y'];
cout << "\nIf the component key is z, the component value is "<< m['z'];

return 0;
}```
Solution
Output:

The newly created map is currently empty.

After entering the three key/value pairs, the size of the map is now 3.

If the component key is x, the component value is 1
If the component key is y, the component value is 2
If the component key is z, the component value is 3