What is the right way of initializing a static map? Do we need a static function that will initialize it? 

Initializing a static std::map&lt;int, int&gt; in C++

This is one of the possible ways I come out:

    struct RetrieveKey
    {
        template &lt;typename T&gt;
        typename T::first_type operator()(T keyValuePair) const
        {
            return keyValuePair.first;
        }
    };

    map&lt;int, int&gt; m;
    vector&lt;int&gt; keys;

    // Retrieve all keys
    transform(m.begin(), m.end(), back_inserter(keys), RetrieveKey());

    // Dump all keys
    copy(keys.begin(), keys.end(), ostream_iterator&lt;int&gt;(cout, &quot;\n&quot;));

Of course, we can also retrieve all values from the map by defining another functor **RetrieveValues**.

Is there any other way to achieve this easily? (I&#39;m always wondering why `std::map` does not include a member function for us to do so.)

How to retrieve all keys (or values) from a std::map and put them into a vector?

A while ago, I had a discussion with a colleague about how to insert values in STL [maps][1]. I preferred `map[key] = value;` because it feels natural and is clear to read whereas he preferred `map.insert(std::make_pair(key, value))`.

I just asked him and neither of us can remember the reason why insert is better, but I am sure it was not just a style preference rather there was a technical reason such as efficiency. The [SGI STL reference][1] simply says: &quot;Strictly speaking, this member function is unnecessary: it exists only for convenience.&quot;

Can anybody tell me that reason, or am I just dreaming that there is one?

  [1]: http://www.sgi.com/tech/stl/Map.html

In STL maps, is it better to use map::insert than []?

I have identified four different ways of inserting elements into a `std::map`:

    std::map&lt;int, int&gt; function;

    function[0] = 42;
    function.insert(std::map&lt;int, int&gt;::value_type(0, 42));
    function.insert(std::pair&lt;int, int&gt;(0, 42));
    function.insert(std::make_pair(0, 42));

Which of those is the preferred/idiomatic way? (And is there another way I have not thought of?)

What is the preferred/idiomatic way to insert into a map?

Is there a way to specify the default value ``std::map``&#39;s ``operator[]`` returns when an key does not exist?



std::map default value

&gt; **Possible Duplicate:**  
&gt; [In STL maps, is it better to use map::insert than []?](https://stackoverflow.com/questions/326062/in-stl-maps-is-it-better-to-use-mapinsert-than)  

&lt;!-- End of   automatically     inserted sorry about text --&gt;

I was wondering, when I insert element into map, what is the recommended way. Should I

    map[key] = value;

or

    map.insert(std::pair&lt;key_type, value_type&gt;(key, value));

I did the following quick test:

    #include &lt;map&gt;
    #include &lt;string&gt;
    #include &lt;iostream&gt;
    
    class Food {
    public:
    	Food(const std::string&amp; name) : name(name) { std::cout &lt;&lt; &quot;constructor with string parameter&quot; &lt;&lt; std::endl; }
    	Food(const Food&amp; f) : name(f.name) { std::cout &lt;&lt; &quot;copy&quot; &lt;&lt; std::endl; }
    	Food&amp; operator=(const Food&amp; f) { name = f.name; std::cout &lt;&lt; &quot;=&quot; &lt;&lt; std::endl; return *this; } 
    	Food() { std::cout &lt;&lt; &quot;default&quot; &lt;&lt; std::endl; }
    	std::string name;
    };
    
    int main() {
    	std::map&lt;std::string, Food&gt; m0;
    
    /*
    1) constructor with string parameter
    2) copy
    3) copy
    4) copy
    */
    	m0.insert(std::pair&lt;std::string, Food&gt;(&quot;Key&quot;, Food(&quot;Ice Cream&quot;)));
    
    /*
    1) constructor with string parameter
    2) default
    3) copy
    4) copy
    5) =
    */
    	// If we do not provide default constructor.
    	// C2512: &#39;Food::Food&#39; : no appropriate default constructor available
    	m0[&quot;Key&quot;] = Food(&quot;Ice Cream&quot;);
    }

 1. I realize by using member function `insert`, less value&#39;s function call will be involved. So, is using `insert` a recommended way?
 2. Why default constructor is needed, when `map[key] = value` way is being used?

I know that `insert` doesn&#39;t overwrite existence key value pair, but `map[key] = value` does. However, is this the only factor I take into consideration, when try to choose among the both?

How about

 1. **Performance**
 2. **Availability of value&#39;s default constructor**
 3. **???**

Recommended way to insert elements into map

    typedef map&lt;string, string&gt; myMap;

When inserting a new pair to `myMap`, it will use the key `string` to compare by its own string comparator. Is it possible to override that comparator? For example, I&#39;d like to compare the key `string` by its length, not by the alphabet. Or is there any other way to sort the map?

How can I create my own comparator for a map?

Assuming a map where you want to preserve existing entries. 20% of the time, the entry you are inserting is new data.  Is there an advantage to doing std::map::find then std::map::insert using that returned iterator?  Or is it quicker to attempt the insert and then act based on whether or not the iterator indicates the record was or was not inserted?

std::map insert or std::map find?

How to update the value of a key in `std::map` after using the `find` method?

I have a map and iterator declaration like this:

    map &lt;char, int&gt; m1;
    map &lt;char, int&gt;::iterator m1_it;
    typedef pair &lt;char, int&gt; count_pair;

I&#39;m using the map to store the number of occurrences of a character. 

I&#39;m using Visual C++ 2010.

How to update std::map after using the find method?

I am trying to figure out why the following code is not working, and I am assuming it is an issue with using char* as the key type, however I am not sure how I can resolve it or why it is occuring. All of the other functions I use (in the HL2 SDK) use `char*` so using `std::string` is going to cause a lot of unnecessary complications.

    std::map&lt;char*, int&gt; g_PlayerNames;

    int PlayerManager::CreateFakePlayer()
    {
    	FakePlayer *player = new FakePlayer();
    	int index = g_FakePlayers.AddToTail(player);
    
    	bool foundName = false;
    
    	// Iterate through Player Names and find an Unused one
    	for(std::map&lt;char*,int&gt;::iterator it = g_PlayerNames.begin(); it != g_PlayerNames.end(); ++it)
    	{
    		if(it-&gt;second == NAME_AVAILABLE)
    		{
    			// We found an Available Name. Mark as Unavailable and move it to the end of the list
    			foundName = true;
    			g_FakePlayers.Element(index)-&gt;name = it-&gt;first;
    
    			g_PlayerNames.insert(std::pair&lt;char*, int&gt;(it-&gt;first, NAME_UNAVAILABLE));
    			g_PlayerNames.erase(it); // Remove name since we added it to the end of the list
    
    			break;
    		}
    	}
    
    	// If we can&#39;t find a usable name, just user &#39;player&#39;
    	if(!foundName)
    	{
    		g_FakePlayers.Element(index)-&gt;name = &quot;player&quot;;
    	}
    
    	g_FakePlayers.Element(index)-&gt;connectTime = time(NULL);
    	g_FakePlayers.Element(index)-&gt;score = 0;
    
    	return index;
    }

Using char* as a key in std::map

I&#39;m wondering why I can&#39;t use STL maps with user-defined classes. When I compile the code below, I get the following cryptic error message. What does it mean? Also, why is it only happening with user-defined types? (Primitive types are okay when they are used as key.)

&gt; C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\c++\3.4.5\bits\stl_function.h||In
&gt; member function `bool
&gt; std::less&lt;_Tp&gt;::operator()(const _Tp&amp;,
&gt; const _Tp&amp;) const [with _Tp =
&gt; Class1]&#39;:|
&gt;
&gt; C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\c++\3.4.5\bits\stl_map.h|338|instantiated
&gt; from `_Tp&amp; std::map&lt;_Key, _Tp,
&gt; _Compare, _Alloc&gt;::operator[](const _Key&amp;) [with _Key = Class1, _Tp = int, _Compare = std::less&lt;Class1&gt;, _Alloc = std::allocator&lt;std::pair&lt;const Class1,
&gt; int&gt; &gt;]&#39;|
&gt;
&gt; C:\Users\Admin\Documents\dev\sandbox\sandbox\sandbox.cpp|24|instantiated
&gt; from here|
&gt;
&gt; C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\c++\3.4.5\bits\stl_function.h|227|error: no match for &#39;operator&lt;&#39; in &#39;__x &lt;
&gt; __y&#39;| ||=== Build finished: 1 errors, 0 warnings ===|



    #include &lt;iostream&gt;
    #include &lt;map&gt;
    
    using namespace std;
    
    class Class1
    {
    public:
        Class1(int id);
    
    private:
        int id;
    };
    
    Class1::Class1(int id): id(id)
    {}
    
    int main()
    {
        Class1 c1(1);
    
        map&lt; Class1 , int&gt; c2int;
        c2int[c1] = 12;
    
        return 0;
    }

How can I use std::maps with user-defined types as key?

How can I merge two STL maps into one? They both have the same key and value types (`map&lt;string, string&gt;`). If there is an overlap of the keys, I would like to give preference to one of the maps.

How can I merge two STL maps?

What is the difference between the following two lines?

    map&lt;int, float&gt; map_data;
    map&lt;const int, float&gt; map_data;


What is difference between const and non const key?

I have a `map` named `valueMap` as follows:

    typedef std::map&lt;std::string, std::string&gt;MAP;
    MAP valueMap;
    ...
    // Entering data.
    
Then I am passing this map to a function by reference:

    void function(const MAP &amp;map)
    {
      std::string value = map[&quot;string&quot;];
      // By doing so I am getting an error.
    }

How can I get the value from the map, which is passed as a reference to a function?

How can I get a value from a map?

So there seem to be two generally acceptable methods of determining whether or not a key exists in a `std::map`:

    map.find(key) != map.end()
    map.count(key) &gt; 0

Is one more efficient than the other? Specifically, the concept of `count()` could be interpreted to mean that the method will iterate over every key, tallying a total count (and because of the definition of `std::map`, that total count will always be 0 or 1). Is `count()` guaranteed to &quot;stop&quot; after a match, operating at the same complexity as a `find()`?

Checking for existence in std::map - count vs find

I would like to loop through an `std::map` and delete items based on their contents. How best would this be done?

How can I delete elements of a std::map with an iterator?

I am looking for the highest key value (a defined by the comparison operator) of a std::map&lt;int, something&gt;.

Is this guaranteed to be 

    map.rbegin()-&gt;first

? 

(I am a bit shaky on reverse iterators, and how much freedom there is in the implementation of std::map) 

If not, please advise. I cannot change the data structure.

Last key in a std::map

I have the following issue related to iterating over an associative array of strings defined using `std::map`.

    -- snip --
    class something 
    {
    //...
       private:
          std::map&lt;std::string, std::string&gt; table;
    //...
    }

In the constructor I populate table with pairs of string keys associated to string data. Somewhere else I have a method `toString` that returns a string object that contains all the keys and associated data contained in the table object(as key=data format).

    std::string something::toString() 
    {
            std::map&lt;std::string, std::string&gt;::iterator iter;
            std::string* strToReturn = new std::string(&quot;&quot;);
    
            for (iter = table.begin(); iter != table.end(); iter++) {
               strToReturn-&gt;append(iter-&gt;first());
               strToReturn-&gt;append(&#39;=&#39;);
               strToRetunr-&gt;append(iter-&gt;second());
               //....
            }
           //...
    }

When I&#39;m trying to compile I get the following error:

    error: &quot;error: no match for call to ‘(std::basic_string&lt;char,
        std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;) ()’&quot;.
 
Could somebody explain to me what is missing, what I&#39;m doing wrong? 
I only found some discussion about a similar issue in the case of `hash_map` where the user has to define a hashing function to be able to use `hash_map` with `std::string` objects. Could be something similar also in my case?

How to iterate over a std::map full of strings in C++

Is there a way in C++ to search for the mapped value (instead of the key) of a map, and then return the key? Usually, I do `someMap.find(someKey)-&gt;second` to get the value, but here I want to do the opposite and obtain the key (the values and keys are all unique).

Find mapped value of map

I have a map where I&#39;d like to perform a call on every data type object member function. I yet know how to do this on any sequence but, is it possible to do it on an associative container?

The closest answer I could find was this: [Boost.Bind to access std::map elements in std::for_each][1]. But I cannot use boost in my project so, is there an STL alternative that I&#39;m missing to boost::bind?

If not possible, I thought on creating a temporary sequence for pointers to the data objects and then, call for_each on it, something like this:

    class MyClass
    {
    public:
     void Method() const;
    }
    
    std::map&lt;int, MyClass&gt; Map;
    //...
    
    std::vector&lt;MyClass*&gt; Vector;
    std::transform(Map.begin(), Map.end(), std::back_inserter(Vector), std::mem_fun_ref(&amp;std::map&lt;int, MyClass&gt;::value_type::second));
    std::for_each(Vector.begin(), Vector.end(), std::mem_fun(&amp;MyClass::Method));

It looks too obfuscated and I don&#39;t really like it. Any suggestions?

  [1]: https://stackoverflow.com/questions/2311752/boost-bind-to-access-stdmap-elements-in-stdfor-each


Use of for_each on map elements

I have read different articles on web and questions at [stackoverflow][1], but for me it is not clear is there any exclusive case when it is better to use `std::map::at` to retrieve map element.

According to [definition][2], `std::map::at` 

&gt; Returns a reference to the mapped value of the element identified with
&gt; key k.
&gt; 
&gt; If k does not match the key of any element in the container, the
&gt; function throws an out_of_range exception.

For me only case when it is worth to use `std::map::at` when you 100% sure that element with particular key exist, otherwise you should consider exception handling.

 1. Is there any case where `std::map::at` considered as most efficient and elegant way to do?  In what cases you will recommend to use `std::map::at` ?
 2. Am I right that it is better to use `map::find()` when there is a possibility to not have element with such a key? And `map::find()` it is faster and more elegant approach?

&gt;     if ( map.find(&quot;key&quot;) != map.end() )
&gt;     {
&gt;         // found 
&gt;     
&gt;     } else
&gt;     {
&gt;         // not found
&gt;     }

**p.s** 

`map::operator[]`  sometimes can be dangerous, because if an element doesn&#39;t exist then it will inserts it.

**EDITED:** links somehow related [link 1][3] [link 2][4] [link 3][5] [link 4][6] [link 5][7] [link 6][8]


  [1]: https://stackoverflow.com/search?q=How%20to%20find%20if%20a%20given%20key%20exists%20in%20a%20C%2B%2B%20std%3A%3Amap
  [2]: http://www.cplusplus.com/reference/map/map/at/
  [3]: https://stackoverflow.com/questions/10821405/difference-between-map-and-map-at-in-c
  [4]: https://stackoverflow.com/questions/2781899/how-to-find-whether-an-element-exists-in-stdmap
  [5]: https://stackoverflow.com/questions/1939953/how-to-find-if-a-given-key-exists-in-a-c-stdmap
  [6]: https://stackoverflow.com/questions/3136520/determine-if-map-contains-a-value-for-a-key
  [7]: https://stackoverflow.com/questions/535317/checking-value-exist-in-a-stdmap-c
  [8]: https://stackoverflow.com/questions/10582089/stl-map-should-use-find-or-n-identifier-to-find-element-in-map

When I should use std::map::at to retrieve map element

I have a `std::map` that I&#39;m using to store values for x and y coordinates. My data is very sparse, so I don&#39;t want to use arrays or vectors, which would result in a massive waste of memory. My data ranges from -250000 to 250000, but I&#39;ll only have a few thousand points at the most.

Currently I&#39;m creating a `std::string` with the two coordinates (i.e. `&quot;12x45&quot;`) and using it as a key. This doesn&#39;t seem like the best way to do it.

My other thoughts were to use an int64 and shove the two int32s into it and use it as a key.

Or to use a class with the two coordinates. What are the requirements on a class that is to be used as the key?

What is the best way to do this? I&#39;d rather not use a map of maps.

What is the best way to use two keys with a std::map?

I understand that references are not pointers, but an alias to an object.  However, I still don&#39;t understand what exactly this means to me as a programmer, i.e. what are references under the hood?

I think the best way to understand this would be to understand why it is I can&#39;t store a reference in a map.

I know I need to stop thinking of references as syntactic suger over pointers, just not sure how to :/

Why Can&#39;t I store references in a `std::map` in C++?

What is the difference between `std::list&lt;std::pair&gt;` and `std::map`? Is there a `find` method for the list, too?

All Stdmap Solutions on Gang of Coders

Total of 24 Stdmap Solutions

Initializing a static std::map<int, int> in C++