map/multimap

A map is a data structure in which each element is made up of two parts: a key and a value. The key field is a unique identification value that is used to order and access the elements of the structure. The value field is the actual data that is stored for the particular key.

map< key_type, value_type > mapName;

map< key_type, value_type, compare_type > mapName;

map< key_type, value_type > mapName( otherMap );

map< key_type, value_type, compare_type > mapName( otherMap );

The default ordering (or comparison) for a map is less than but that can be changed when a map is created.

Member Functions

As with the other containers, the map class contains the common methods such as:

iterator begin();
iterator end();
void clear();
void erase( iterator );
void erase( start_iterator, end_iterator ); bool empty() const;
int size() const;

Some of the other methods in the class include:

Method	Description
int count( const key_type& key_value ) const;	Returns the number of elements in the map with the key key_value. (0 or 1)
int erase( const key_type& key_value );	Removes the element with the key key_value and returns the number that were removed. (0 or 1)
iterator find( const key_type& key_value);	Returns an iterator referencing the element with key key_value.
pair<key_type, value_type> insert( const pair<key_type, value_type>(key_value, value));	Inserts the pair (key_value, value) into the map BEFORE the element referenced by iterator i.
iterator insert( iterator i, const pair<key_type, value_type>(key_value, value));	Inserts the pair (key_value, value) into the map BEFORE the element referenced by iterator i.
void insert( iterator first, iterator last );	Insert pairs from the range indicated by first and last.
compare_type key_comp() const;	Returns the comparison function for keys.
value_type operator[]( const key_type& key_value );	Return the element with the key key_value if it is in the map; otherwise insert it in the map.

maps and iterators

The map container allows for all of the standard iterator operations and methods. An iterator can also be used to access the key and value fields by using the members: first and second.

The first member references the key value for a map element, while the second member references the value field for a map element.

map<key_type, value_type>::iterator mapIter;

(*mapIter).first   OR   mapIter->first               //both will give the key value

(*mapIter).second  OR   mapIter->second              //both will give the value field for the element

(*mapIter)                                           //gives the element value, which is of type pair<key_type, value_type>

Examples

map<string, int> wordcounts;
string s;
 
while( cin >> s && s != "end" )
  wordcounts[s]++;
  
---------------------------------------------------------------------------


map<char, int> myMap;
char c;


// insert elements using insert function

myMap.insert(pair<char, int>('a', 1));
myMap.insert(pair<char, int>('b', 2));
myMap.insert(pair<char, int>('c', 3));
myMap.insert(pair<char, int>('d', 4));
myMap.insert(pair<char, int>('e', 5));

 
// erase the first element using the erase function

map<char, int>::iterator iter = myMap.begin();

myMap.erase(iter);
 

// output the size of the map

cout << "Size of myMap: " << myMap.size() << endl;
 
cout << "Enter a key to search for: ";
cin >> c;
 

// find will return an iterator to the matching element if it is found
// or to the end of the map if the key is not found

iter = myMap.find( c );

if( iter != myMap.end() ) 
  cout << "Value is: " << iter->second << endl;

else
  cout << "Key is not in myMap" << endl;
 

// clear the entries in the map

myMap.clear();
  
---------------------------------------------------------------------------


map<string, int> data;

map<string, int>::iterator it

 
data["Bob"] = 10;
data["Marty"] = 15;
data["Melvin"] = 34;
data["Robert"] = 22;
 

// Iterate over the map and print out all key/value pairs.

for( it = data.begin(); it != data.end(); it++ )
{
cout << "Who: " << it->first;
cout << " Score): " << it->second << endl;
}

multimap

A multimap is a map that allows for duplicate keys. It uses the same member functions as the map contain with the exception of one of the insert methods

     pair<key_type, value_type> insert(  const pair<key_type, value_type>(key_value, value));

is not supported for a multimap. It is replaced by:

     iterator insert(  const pair<key_type, value_type>(key_value, value));

which returns an iterator referencing the position where the pair(key_value, value) was inserted.

The other method that is not supported is the operator[] (subscript operator) method. In order to modify an element in a multimap, the best approach is to find the element using the find() method and the second member.