map and multimap in c++

Map and multimap containers are containers that manage key/value pairs as elements. They sort their elements automatically according to a certain sorting criterion that is used for the actual key. The difference between the two is that multimaps allow duplicates, whereas maps do not (figure below).

Figure: Maps and Multimaps

To use a map or multimap, you must include the header file <map>:

#include <map>

There, the type is defined as a class template inside namespace std:

namespace std { template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key,T> > > class map; template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key,T> > > class multimap; }

The first template argument is the type of the element's key, and the second template argument is the type of the element's value. The elements of a map or multimap may have any types Key and T that meet the following two requirements:

1. The key/value pair must be assignable and copyable.
   
2. The key must be comparable with the sorting criterion.

The optional third template argument defines the sorting criterion. Like sets, this sorting criterion must define a "strict weak ordering" The elements are sorted according to their keys, thus the value doesn't matter for the order of the elements. The sorting criterion is also used to check equality; that is, two elements are equal if neither key is less than the other. If a special sorting criterion is not passed, the default criterion less is used. The function object less sorts the elements by comparing them with operator <

The optional fourth template parameter defines the memory model. The default memory model is the model allocator, which is provided by the C++ standard library.

Abilities of Maps and Multimaps

Like all standardized associative container classes, maps and multimaps are usually implemented as balanced binary trees (figure below). The standard does not specify this but it follows from the complexity of the map and multimap operations. In fact, sets, multisets, maps, and multimaps typically use the same internal data type. So, you could consider sets and multisets as special maps and multimaps, respectively, for which the value and the key of the elements are the same objects. Thus, maps and multimaps have all the abilities and operations of sets and multisets. Some minor differences exist, however. First, their elements are key/value pairs. In addition, maps can be used as associative arrays.

Figure: Internal Structure of Maps and Multimaps

Maps and multimaps sort their elements automatically according to the element's keys. Thus they have good performance when searching for elements that have a certain key. Searching for elements that have a certain value promotes bad performance. Automatic sorting imposes an important constraint on maps and multimaps: You may not change the key of an element directly because this might compromise the correct order. To modify the key of an element, you must remove the element that has the old key and insert a new element that has the new key and the old value. As a consequence, from the iterator's point of view, the element's key is constant. However, a direct modification of the value of the element is still possible (provided the type of the value is not constant).

Map and Multimap Operations

Create, Copy, and Destroy Operations

Table below lists the constructors and destructors of maps and multimaps.

Table:- Constructors and Destructors of Maps and Multimaps

Operation	Effect
map c	Creates an empty map/multimap without any elements
map c(op)	Creates an empty map/multimap that uses op as the sorting criterion
map c1(c2)	Creates a copy of another map/multimap of the same type (all elements are copied)
map c(beg,end)	Creates a map/multimap initialized by the elements of the range [beg,end)
map c(beg,end,op)	Creates a map/multimap with the sorting criterion op initialized by the elements of the range [beg,end)
c. ~map ()	Destroys all elements and frees the memory

Here, map may be one of the following:

Map	Effect
map<Key,Elem>	A map that sorts keys with less<> (operator <)
map<Key,Elem,Op>	A map that sorts keys with Op
multimap<Key,Elem>	A multimap that sorts keys with less<> (operator <)
multimap<Key,Elem,Op>	A multimap that sorts keys with Op

You can define the sorting criterion in two ways:

1. As a template parameter.
   For example:
   std::map<float,std::string,std::greater<float> > coll;
   
   In this case, the sorting criterion is part of the type. Thus, the type system ensures that only containers with the same sorting criterion can be combined. This is the usual way to specify the sorting criterion. To be more precise, the third parameter is the type of the sorting criterion. The concrete sorting criterion is the function object that gets created with the container. To do this, the constructor of the container calls the default constructor of the type of the sorting criterion.
2. As a constructor parameter.
   
   In this case you might have a type for several sorting criteria, and the initial value or state of the sorting criteria might differ. This is useful when processing the sorting criterion at runtime, or when sorting criteria are needed that are different but of the same data type. A typical example is specifying the sorting criterion for string keys at runtime.

If no special sorting criterion is passed, the default sorting criterion, function object less<>, is used. which sorts the elements by using operator <.

map<float,string,less<float> > coll;

You should make a type definition to avoid the boring repetition of the type whenever it is used:

typedef std::map<std::string,float,std::greater<string> > StringFloatMap; ... StringFloatMap coll;

The constructor for the beginning and the end of a range could be used to initialize the container with elements from containers that have other types, from arrays, or from the standard input. However, the elements are key/value pairs, so you must ensure that the elements from the source range have or are convertible into type pair<key,value>.

Nonmodifying and Special Search Operations

Maps and multimaps provide the usual nonmodifying operations - those that query size aspects and make comparisons (table below).

Table :- Nonmodifying Operations of Maps and Multimaps

Operation	Effect
c.size()	Returns the actual number of elements
c.empty()	Returns whether the container is empty (equivalent to size()==0, but might be faster)
c.max_size()	Returns the maximum number of elements possible
c1 == c2	Returns whether c1 is equal to c2
c1 != c2	Returns whether c1 is not equal to c2 (equivalent to !(c1==c2))
c1 < c2	Returns whether c1 is less than c2
c1 > c2	Returns whether c1 is greater than c2 c2<c1)
c1 <= c2	Returns whether c1 is less than or equal to c2 (equivalent to !(c2<c1))
c1 >= c2	Returns whether c1 is greater than or equal to c2 (equivalent to !(c1<c2))

Comparisons are provided only for containers of the same type. Thus, the key, the value, and the sorting criterion must be of the same type. Otherwise, a type error occurs at compile time. For example:

std::map<float,std::string> c1; // sorting criterion: less<> std::map<float,std::string,std::greater<float> > c2; ... if (c1 == c2) { // ERROR: different types ... }

To check whether a container is less than another container is done by a lexicographical comparison. To compare containers of different types (different sorting criterion),

Special Search Operations

Like sets and multisets, maps and multimaps provide special search member functions that perform better because of their internal tree structure (table below).

The find() member function searches for the first element that has the appropriate key and returns its iterator position. If no such element is found, find() returns end() of the container. You can't use the find() member function to search for an element that has a certain value. Instead, you have to use a general algorithm such as the find_if() algorithm, or program an explicit loop. Here is an example of a simple loop that does something with each element that has a certain value:

std::multimap<std::string,float> coll; ... //do something with all elements having a certain value std::multimap<std::string,float>::iterator pos; for (pos = coll.begin(); pos != coll.end(); ++pos) { if (pos->second == value) { do_something(); } }

Table :- Special Search Operations of Maps and Multimaps

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)

Be careful when you want to use such a loop to remove elements. It might happen that you saw off the branch on which you are sitting. Using the find_if() algorithm to search for an element that has a certain value is even more complicated than writing a loop because you have to provide a function object that compares the value of an element with a certain value.

The lower_bound(), upper_bound(), and equal_range() functions behave as they do for sets (see page 180), except that the elements are key/value pairs. 

Assignments

Maps and multimaps provide only the fundamental assignment operations that all containers provide (table below)

Table :- Assignment Operations of Maps and Multimaps

Operation	Effect
c1 = c2	Assigns all elements of c2 c1
c1.swap(c2)	Swaps the data of c1 and c2
swap(c1,c2)	Same (as global function)

For these operations both containers must have the same type. In particular, the type of the comparison criteria must be the same, although the comparison criteria themselves may be different. If the criteria are different, they also get assigned or swapped. 

Iterator Functions and Element Access

Maps and multimaps do not provide direct element access, so the usual way to access elements is via iterators. An exception to that rule is that maps provide the subscript operator to access elements directly. Table below lists the usual member functions for iterators that maps and multimaps provide.

Table 6.30. Iterator Operations of Maps and Multimaps

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

As for all associative container classes, the iterators are bidirectional. Thus, you can't use them in algorithms that are provided only for random access iterators (such as algorithms for sorting or random shuffling).

More important is the constraint that the key of all elements inside a map and a multimap is considered to be constant. Thus, the type of the elements is pair<const Key, T>. This is also necessary to ensure that you can't compromise the order of the elements by changing their keys. However, you can't call any modifying algorithm if the destination is a map or multimap. For example, you can't call the remove() algorithm to remove elements because it "removes" only by overwriting "removed" elements with the following arguments. To remove elements in maps and multimaps, you can use only member functions provided by the container.

The following is an example of the use of iterators:

std::map<std::string,float> coll; ... std::map<std::string,float>::iterator pos; for (pos = coll.begin(); pos != coll.end(); ++pos) { std::cout << "key: " << pos->first << "\t" << "value: " << pos->second << std::endl; }
Here, the iterator pos iterates through the sequence of string/float pairs. The expression

pos->first
yields the key of the actual element, whereas the expression

pos->second
yields the value of the actual element.

Trying to change the value of the key results in an error:

pos->first = "hello"; // ERROR at compile time
However, changing the value of the element is no problem (as long as the type of the value is not constant):

pos->second = 13.5; // OK

To change the key of an element, you have only one choice: You must replace the old element with a new element that has the same value. Here is a generic function that does this:

namespace MyLib { template <class Cont> inline bool replace_key (Cont& c, const typename Cont::key_type& old_key, const typename Cont::key_type& new_key) { typename Cont::iterator pos; pos = c.find(old_key); if (pos != c.end()) { //insert new element with value of old element c.insert(typename Cont::value_type(new_key, pos->second)); //remove old element c.erase(pos); return true; } else { //key not found return false; } } }

The insert() and erase() member functions are discussed in the next subsection.

To use this generic function you simply must pass the container the old key and the new key. For example:

std::map<std::string,float> coll; ... MyLib::replace_key(coll,"old key","new key");
It works the same way for multimaps.

Note that maps provide a more convenient way to modify the key of an element. Instead of calling replace_key(), you can simply write the following:

//insert new element with value of old element coll["new_key"] = coll["old_key"]; //remove old element coll.erase("old_key");
Inserting and Removing Elements

Table below shows the operations provided for maps and multimaps to insert and remove elements.

Table :- Insert and Remove Operations of Maps and Multimaps

Operation	Effect
c.insert(elem)	Inserts a copy of elem and returns the position of the new element and, for maps, whether it succeeded
c.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)
c.insert(beg,end)	Inserts a copy of all elements of the range [beg,end)(returns nothing)
c.erase(elem)	Removes all elements with value elem and returns the number of removed elements
c.erase(pos)	Removes the element at iterator position pos (returns nothing)
c.erase(beg,end)	Removes all elements of the range [beg,end)(returns nothing)
c.clear()	Removes all elements (makes the container empty)

In particular, the return types of these operations have the same differences as they do for sets and multisets. However, note that the elements here are key/value pairs. So, the use is getting a bit more complicated.

To insert a key/value pair, you must keep in mind that inside maps and multimaps the key is considered to be constant. You either must provide the correct type or you need to provide implicit or explicit type conversions. There are three different ways to pass a value into a map:

1. Use value_type
   
   To avoid implicit type conversion, you could pass the correct type explicitly by using value_type, which is provided as a type definition by the container type. For example:
   
   std::map<std::string,float> coll; ... coll.insert(std::map<std::string,float>::value_type("otto", 22.3));
   
2. Use pair<>
   
   Another way is to use pair<> directly. For example:
   
   std::map<std::string,float> coll; ... //use implicit conversion: coll.insert(std::pair<std::string,float>("otto",22.3)); //use no implicit conversion: coll.insert(std::pair<const std::string,float>("otto",22.3));
   In the first insert() statement the type is not quite right, so it is converted into the real element type. For this to happen, the insert() member function is defined as a member template.

3. Use make_pair()
   
   Probably the most convenient way is to use the make_pair() function. This function produces a pair object that contains the two values passed as arguments:
   
   std::map<std::string,float> coll; ... coll.insert(std::make_pair("otto",22.3));
   Again, the necessary type conversions are performed by the insert() member template.

Here is a simple example of the insertion of an element into a map that also checks whether the insertion was successful:

std::map<std::string,float> coll; ... if (coll.insert(std::make_pair("otto",22.3)).second) { std::cout << "OK, could insert otto/22.3" << std::endl; } else { std::cout << "Oops, could not insert otto/22.3 " << "(key otto already exists)" << std::endl; }
To remove an element that has a certain value, you simply call erase():

std::map<std::string,float> coll; ... //remove all elements with the passed key coll.erase(key);

This version of erase() returns the number of removed elements. When called for maps, the return value of erase() can only be 0 or 1.

If a multimap contains duplicates, you can't use erase() to remove only the first element of these duplicates. Instead, you could code as follows:

typedef multimap<string.float> StringFloatMMap; StringFloatMMap coll; ... //remove first element with passed key StringFloatMMap::iterator pos; pos = coll.find(key); if (pos != coll.end()) { coll.erase(pos); }

You should use the member function find() instead of the find() algorithm here because it is faster. However, you can't use the find() member functions to remove elements that have a certain value (instead of a certain key).

When removing elements, be careful not to saw off the branch on which you are sitting. There is a big danger that will you remove an element to which your iterator is referring. For example:

typedef std::map<std::string,float> StringFloatMap; StringFloatMap coll; StringFloatMap::iterator pos; ... for (pos = coll.begin(); pos != coll.end(); ++pos) { if (pos->second == value) { coll. erase (pos); // RUNTIME ERROR !!! } }

Calling erase() for the element to which you are referring with pos invalidates pos as an iterator of coll. Thus, if you use pos after removing its element without any reinitialization, then all bets are off. In fact, calling ++pos results in undefined behavior.

A solution would be easy if erase() always returned the value of the following element:

typedef std::map<std::string,float> StringFloatMap; StringFloatMap coll; StringFloatMap::iterator pos; ... for (pos = coll.begin(); pos != coll.end(); ) { if (pos->second == value) { pos = coll.erase(pos); // would be fine, but COMPILE TIME ERROR } else { ++pos; } }

It was a design decision not to provide this trait, because if not needed, it costs unnecessary time. I don't agree with this decision however, because code is getting more error prone and complicated (and may cost even more in terms of time).

Here is an example of the correct way to remove elements to which an iterator refers:

typedef std::map<std::string,float> StringFloatMap; StringFloatMap coll; StringFloatMap::iterator pos, tmp_pos; ... //remove all elements having a certain value for (pos = c.begin(); pos != c.end(); ) { if (pos->second == value) { c.erase(pos++); } else { ++pos; } }
Note that pos++ increments pos so that it refers to the next element but yields a copy of its original value. Thus, pos doesn't refer to the element that is removed when erase() is called.

Using Maps as Associative Arrays

Associative containers don't typically provide abilities for direct element access. Instead, you must use iterators. For maps, however, there is an exception to this rule. Nonconstant maps provide a subscript operator for direct element access (table below). However, the index of the subscript operator is not the integral position of the element. Instead, it is the key that is used to identify the element. This means that the index may have any type rather than only an integral type. Such an interface is the interface of a so-called associative array.

Table :- Direct Element Access of Maps with Operator [ ]

Operation	Effect
m[key]	Returns a reference to the value of the element with key key Inserts an element with key if it does not yet exist

The type of the index is not the only difference from ordinary arrays. In addition, you can't have a wrong index. If you use a key as the index, for which no element yet exists, a new element gets inserted into the map automatically. The value of the new element is initialized by the default constructor of its type. Thus, to use this feature you can't use a value type that has no default constructor. Note that the fundamental data types provide a default constructor that initializes their values to zero.

This behavior of an associative array has both advantages and disadvantages:

• The advantage is that you can insert new elements into a map with a more convenient interface.
  For example:
  
  std::map<std::string,float> coll; // empty collection /*insert "otto"/7.7 as key/value pair *-first it inserts "otto"/float() *-then it assigns 7.7 */ coll["otto"] = 7.7;
  The statement
  
  coll["otto"] = 7.7;
  
  is processed here as follows:
  1. Process coll["otto"] expression:
     • If an element with key "otto" exists, the expression returns the value of the element by reference.
       
     • If, as in this example, no element with key "otto" exists, the expression inserts a new element automatically with "otto" as key and the value of the default constructor of the value type as the element value. It then returns a reference to that new value of the new element.
  2. Assign value 7.7:
     • The second part of the statement assigns 7.7 to the value of the new or existing element.
  The map then contains an element with key "otto" and value 7.7.
• The disadvantage is that you might insert new elements by accident or mistake. For example, the following statement does something you probably hadn't intended or expected:
  
  std::cout << coll ["ottto"];
  
  It inserts a new element with key "ottto" and prints its value, which is 0 by default. However, it should have generated an error message telling you that you wrote "otto" incorrectly.
  Note, too, that this way of inserting elements is slower than the usual way for maps. This is because the new value is first initialized by the default value of its type, which is then overwritten by the correct value.

Exception Handling

Maps and multimaps provide the same behavior as sets and multisets with respect to exception safety. This behavior is mentioned on page 185.

Examples of Using Maps and Multimaps

Using a Map as an Associative Array

The following example shows the use of a map as an associative array. The map is used as a stock chart. The elements of the map are pairs in which the key is the name of the stock and the value is its price:

#include <iostream> #include <map> #include <string> using namespace std; int main() { /*create map/associative array *-keys are strings *-values are floats */ typedef map<string,float> StringFloatMap; StringFloatMap stocks; // create empty container //insert some elements stocks["BASF"] = 369.50; stocks["VW"] = 413.50; stocks["Daimler"] = 819.00; stocks["BMW"] = 834.00; stocks["Siemens"] = 842.20; //print all elements StringFloatMap::iterator pos; for (pos = stocks.begin(); pos != stocks.end(); ++pos) { cout << "stock: " << pos->first << "\t" << "price: " << pos->second << endl; } cout << endl; //boom (all prices doubled) for (pos = stocks.begin(); pos != stocks.end(); ++pos) { pos->second *= 2; } //print all elements for (pos = stocks.begin(); pos != stocks.end(); ++pos) { cout << "stock: " << pos->first << "\t" << "price: " << pos->second << endl; } cout << endl; /*rename key from "VW" to "Volkswagen" *-only provided by exchanging element */ stocks["Volkswagen"] = stocks["VW"]; stocks.erase("VW"); //print all elements for (pos = stocks.begin(); pos != stocks.end(); ++pos) { cout << "stock: " << pos->first << "\t" << "price: " << pos->second << endl; } }
The program has the following output:

stock: BASF price: 369.5 stock: BMW price: 834 stock: Daimler price: 819 stock: Siemens price: 842.2 stock: VW price: 413.5 stock: BASF price: 739 stock: BMW price: 1668 stock: Daimler price: 1638 stock: Siemens price: 1684.4 stock: VW price: 827 stock: BASF price: 739 stock: BMW price: 1668 stock: Daimler price: 1638 stock: Siemens price: 1684.4 stock: Volkswagen price: 827
Using Multimap as a  Directory

The following example shows how to use a multimap as a dictionary:

#include <iostream> #include <map> #include <string> #include <iomanip> using namespace std; int main() { //define multimap type as string/string dictionary typedef multimap<string,string> StrStrMMap; //create empty dictionary StrStrMMap dict; //insert some elements in random order dict.insert(make_pair("day","Tag")); dict.insert(make_pair("strange","fremd")); dict.insert(make_pair("car","Auto")); dict.insert(make_pair("smart","elegant")); dict.insert(make_pair("trait","Merkmal")); dict.insert(make_pair("strange","seltsam")); dict.insert(make_pair("smart","raffiniert")); dict.insert(make_pair("smart","klug")); dict.insert(make_pair("clever","raffiniert")); //print all elements StrStrMMap::iterator pos; cout.setf (ios::left, ios::adjustfield); cout << ' ' << setw(10) << "english " << "german " << endl; cout << setfil('-') << setw(20) << "" << setfil(' ') << endl; for (pos = dict.begin(); pos != dict.end(); ++pos) { cout << ' ' << setw(10) << pos>first.c_str() << pos->second << endl; } cout << endl; //print all values for key "smart" string word("smart"); cout << word << ": " << endl; for (pos = dict.lower_bound(word); pos != dict.upper_bound(word); ++pos) { cout << " " << pos->second << endl; } //print all keys for value "raffiniert" word = ("raffiniert"); cout << word << ": " << endl; for (pos = dict.begin(); pos != dict.end(); ++pos) { if (pos->second == word) { cout << " " << pos->first << endl; } } }
The program has the following output:

english german -------------------- car Auto clever raffiniert day Tag smart elegant smart raffiniert smart klug strange fremd strange seltsam trait Merkmal smart: elegant raffiniert klug raffiniert: clever smart

Find Elements with Certain Values

The following example shows how to use the global find_if() algorithm to find an element with a certain value:

#include <iostream> #include <algorithm> #include <map> using namespace std; /*function object to check the value of a map element */ template <class K, class V> class value_equals { private: V value; public: //constructor (initialize value to compare with) value_equals (const V& v) : value(v) { } //comparison bool operator() (pair<const K, V> elem) { return elem.second == value; } }; int main() { typedef map<float,float> FloatFloatMap; FloatFloatMap coll; FloatFloatMap::iterator pos; //fill container coll[1]=7; coll[2]=4; coll[3]=2; coll[4]=3; coll[5]=6; coll[6]=1; coll[7]=3; //search an element with key 3.0 pos = coll.find (3.0); // logarithmic complexity if (pos != coll.end()) { cout << pos->first << ": " << pos->second << endl; } //search an element with value 3.0 pos = find_if (coll.begin(),coll.end(), // linear complexity value_equals<float,float>(3.0)); if (pos != coll.end()) { cout << pos->first << ": " << pos->second << endl; } }
The output of the program is as follows:

3: 2 4: 3

Example with Maps, Strings, and Sorting Criterion at Runtime

Here is another example. It is for advanced programmers rather than STL beginners. You can take it as an example of both the power and the snags of the STL. In particular, this example demonstrates the following techniques:

• How to use maps
  
• How to write and use function objects
  
• How to define a sorting criterion at runtime
  
• How to compare strings in a case-insensitive way
  
  #include <iostream> #include <iomanip> #include <map> #include <string> #include <algorithm> using namespace std; /*function object to compare strings *-allows you to set the comparison criterion at runtime *-allows you to compare case insensitive */ class RuntimeStringCmp { public: //constants for the comparison criterion enum cmp_mode {normal, nocase}; private: //actual comparison mode const cmp_mode mode; //auxiliary function to compare case insensitive static bool nocase_compare (char c1, char c2) { return toupper(c1) < toupper(c2); } public: //constructor: initializes the comparison criterion RuntimeStringCmp (cmp_mode m=normal) : mode(m) { } //the comparison bool operator() (const string& s1, const string& s2) const { if (mode == normal) { return s1<s2; } else { return lexicographical_compare (s1.begin(), s1.end(), s2.begin(), s2.end(), nocase_compare); } } }; /*container type: *-map with * -string keys * -string values * -the special comparison object type */ typedef map<string,string,RuntimeStringCmp> StringStringMap; //function that fills and prints such containers void fillAndPrint(StringStringMap& coll); int main() { //create a container with the default comparison criterion StringStringMap coll1; fillAndPrint(coll1); //create an object for case-insensitive comparisons RuntimeStringCmp ignorecase (RuntimeStringCmp::nocase); //create a container with the case-insensitive comparisons criterion StringStringMap coll2 (ignorecase); fillAndPrint (coll2); } void fillAndPrint (StringStringMap& coll) { //fill insert elements in random order coll["Deutschland"] = "Germany"; coll["deutsch"] = "German"; coll["Haken"] = "snag"; coll["arbeiten"] = "work"; coll["Hund"] = "dog"; coll["gehen"] = "go"; coll["Unternehmen"] = "enterprise"; coll["unternehmen"] = "undertake"; coll["gehen"] = "walk"; coll["Bestatter"] = "undertaker"; //print elements StringStringMap::iterator pos; cout.setf(ios::left, ios::adjustfield); for (pos=coll.begin(); pos!=coll.end(); ++pos) { cout << setw(15) << pos->first.c_str() << " " << pos->second << endl; } cout << endl; }
  

main() creates two containers and calls fillAndPrint() for them. fillAndPrint() fills the containers with the same elements and prints the contents of them. However, the containers have two different sorting criteria:

1. coll1 uses the default function object of type RuntimeStringCmp, which compares the elements by using operator <.
   
2. coll2 uses a function object of type RuntimeStringCmp that is initialized by value nocase of class RuntimeStringCmp. nocase forces this function object to sort strings in a case-insensitive way.

The program has the following output:

Bestatter undertaker Deutschland Germany Haken snag Hund dog Unternehmen enterprise arbeiten work deutsch German gehen walk unternehmen undertake arbeiten work Bestatter undertaker deutsch German Deutschland Germany gehen walk Haken snag Hund dog Unternehmen undertake

The first block of the output prints the contents of the first container that compares with operator <. The output starts with all uppercase keys followed by all lowercase keys.

The second block prints all case-insensitive items, so the order changed. But note, the second block has one item less. This is because the uppercase word "Unternehmen" is, from a case-insensitive point of view, equal to the lowercase word "unternehmen," and we use a map that does not allow duplicates according to its comparison criterion. Unfortunately the result is a mess because the German key that is the translation for "enterprise" got the value "undertake." So probably a multimap should be used here. This makes sense because a multimap is the typical container for dictionaries.

-----------------------------------------------------------------
See Also:
-----------------------------------------------------------------

• Complete Tutorial of C++ Template's
• Standard Template Library Tutorial
• Inter Process Communication Tutorial
• Advance Programming in C & C++

-----------------------------------------------------------------

The Art of Learning with Innovation,
eLearning Courses for C and C++ Programming Language - The Most appreciated course !!!

Copyright © ccplusplus.com