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

Question

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

Subedit

Answer 1

Using C++11 initializer list {{},{},...}. The order of the initialized elements does not matter. The map will do the ordering by the key for you. If initializing unordered_map, it is the same principle where the sorted order will be determined by the hashing function and will appear to human eye as random:

#include <map>
using namespace std;

map<int, char> m = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};

Using Boost.Assign:

#include <map>
#include "boost/assign.hpp"
using namespace std;
using namespace boost::assign;

map<int, char> m = map_list_of (1, 'a') (3, 'b') (5, 'c') (7, 'd');

Adamsite

Every time I see something like that done with C++, I think of all the horrendous template code that must be behind it. Good example! – Extravert

It is implemented "basically" as an overloaded operator, but if you ever have a syntax error, enjoy that line of code. It pulls in 15 different .hpp's for something that would take you a minute or two. Code for fun? Use it; otherwise, consider the cost to time/size. – Raycher

Boost is great. Wonderful stuff in there. Problem in my case : we can't use it as a company guideline. Not standard enough, not easy enough for the average developer ( not my phrasing ). – Columba

The beauty of all the horrendous template code that implements these utilities is that it is neatly encapsulated in a library and the end user rarely needs to deal with the complexity. – Lyre

@QBziZ: If your company declines using Boost on the grounds of it not being "standard enough", I wonder what C++ library would be "standard enough". Boost is the standard companion for the C++ coder. – Kielce

@Kielce I would like to use boost more, but its synergy with C++11 is terrible, and there are some rather... curious design decisions (Iostreams requires Devices to be copyable, but makes streams noncopyable... oh, and also nonmovable - at least in the implementation I'm using, maybe they fixed it?). – Biedermeier

My problem with Boost (here, and elsewhere) is that you can often get on without it (in this case with C++11 or before C++11 with a function). Boost adds a significant compile time overhead, had tons of files to park into your repository (and to have to copy around/zip/extract if you are making an archive). That's the reason I try not to use it. I know you can choose what files to include/not include, but you usually don't want to have to worry about Boost's cross dependencies with itself so you just copy the whole thing around. – Innocency

My problem with Boost is that it often has several new library dependencies, which generally means MORE packages that need to be installed to work correctly. We already need libstdc++. For example, the Boost ASIO library, requires at least 2 new libraries(probably more) that need to be installed. C++11/14 does make it a lot easier to not need Boost. – Xochitlxp

@nobar apparently, duplicate keys are silently ignored, only the first instance is included. Most probablyn, I just don't have the right compiler options to generate warnings about that. – Stationary

Why this fails to compile on vs2017 with Standard set to c++17 – Combat

Answer 2

Best way is to use a function:

#include <map>

using namespace std;

map<int,int> create_map()
{
  map<int,int> m;
  m[1] = 2;
  m[3] = 4;
  m[5] = 6;
  return m;
}

map<int,int> m = create_map();

Cordite

Nice, I had to just fix build error under MSVS'12, and it was really helpful; faster than setting up boost here. – Circumjacent

Why is this the 'best'? Why for example is it better than @Dreamer's answer? – Openwork

I think it's "best" because it's really simple and doesn't depend on other structures existing (such as the Boost::Assign or a reimplementation of it). And compared to @Dreamer's answer, well, I avoid creating a whole structure only for initializing a map ... – Cordite

Is there a name for this idiom? What "time" is this create_map function running? It runs before main, what is the name for that runtime? – Innocency

Note there is a danger here. extern variables will not have their correct values in this "before main run-time constructor" if the compiler only saw the extern declaration, but has not run into the actual variable definition yet. – Innocency

No, the danger is that there is nothing saying in which order the static variables should be initialized (at least across compilation units). But this is not a problem linked to this question. This is a general problem with static variables. – Cordite

How long does this m going to live? How is its memory allocated? Little bit confused as I always used @eduffy's way. – Nephogram

I like this answer because it's simple and complier friendly. Even with C++ 11, map<int, int> m = {{1,1}, {2,2}}; will not work if your complier does not support it yet. – Coady

no boost AND no C++11 => +1. Notice that function can be used to initialize a const map<int,int> m = create_map() (and so, initialize const members of a class in the initialization list: struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : m(create_map()) – Heliotype

Looks like an ugly hack to me, but it does work in c++98 and that's what I searched for. – Farman

Answer 3

It's not a complicated issue to make something similar to boost. Here's a class with just three functions, including the constructor, to replicate what boost did (almost).

template <typename T, typename U>
class create_map
{
private:
    std::map<T, U> m_map;
public:
    create_map(const T& key, const U& val)
    {
        m_map[key] = val;
    }

    create_map<T, U>& operator()(const T& key, const U& val)
    {
        m_map[key] = val;
        return *this;
    }

    operator std::map<T, U>()
    {
        return m_map;
    }
};

Usage:

std::map mymap = create_map<int, int >(1,2)(3,4)(5,6);

The above code works best for initialization of global variables or static members of a class which needs to be initialized and you have no idea when it gets used first but you want to assure that the values are available in it.

If say, you've got to insert elements into an existing std::map... here's another class for you.

template <typename MapType>
class map_add_values {
private:
    MapType mMap;
public:
    typedef typename MapType::key_type KeyType;
    typedef typename MapType::mapped_type MappedType;

    map_add_values(const KeyType& key, const MappedType& val)
    {
        mMap[key] = val;
    }

    map_add_values& operator()(const KeyType& key, const MappedType& val) {
        mMap[key] = val;
        return *this;
    }

    void to (MapType& map) {
        map.insert(mMap.begin(), mMap.end());
    }
};

Usage:

typedef std::map<int, int> Int2IntMap;
Int2IntMap testMap;
map_add_values<Int2IntMap>(1,2)(3,4)(5,6).to(testMap);

See it in action with GCC 4.7.2 here: http://ideone.com/3uYJiH

############### EVERYTHING BELOW THIS IS OBSOLETE #################

EDIT: The map_add_values class below, which was the original solution I had suggested, would fail when it comes to GCC 4.5+. Please look at the code above for how to add values to existing map.

template<typename T, typename U>
class map_add_values
{
private:
    std::map<T,U>& m_map;
public:
    map_add_values(std::map<T, U>& _map):m_map(_map){}
    map_add_values& operator()(const T& _key, const U& _val)
    {
        m_map[key] = val;
        return *this;
    }
};

Usage:

std::map<int, int> my_map;
// Later somewhere along the code
map_add_values<int,int>(my_map)(1,2)(3,4)(5,6);

NOTE: Previously I used a operator [] for adding the actual values. This is not possible as commented by dalle.

##################### END OF OBSOLETE SECTION #####################

Joost

I'm using your first sample as <int,string> to bind error-numbers (from an enum) with messages - it is working like a charm - thank you. – Bluebottle

operator[] only takes a single argument. – Unseasonable

@dalle: Good catch! For some reason I thought overloaded [] operators could accept more. – Joost

This is a fantastic answer. It's a shame the OP never selected one. You deserve mega props. – Heaves

the map_add_values doesn't work in gcc, which complains: error: conflicting declaration ‘map_add_values<int, int> my_map’ error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’ – Jocasta

@martinwang Which version of gcc? Reading the compiler error it seems like you did something like map_add_values my_map.... Are you using it like shown in my usage example? – Joost

GCC4.5.1. I have tried your example exactly. GCC is just confused by hanging anonymous object. class A{}; A a(); is fine. class A{}; A(); results in a compile error. – Jocasta

@MartinWang, I see. This is the case where GCC thinks that the statement map_add_values<int,int>(my_map)(1,2)(3,4); is like map_add_values<int, int> my_map(1,2)(3,4);. I'm looking into how to come up with a an elegant solution. – Joost

@MartinWang, I have a newer solution. It seems to work with GCC 4.7.2 and you can see it being compiled on ideone. I have moved my original (broken) solution to the end for historical tracking. – Joost

Well, your example is used in main(). Hanging anonymous object is still forbidded in globle namespace. Like class A {public: A(int){} void to(){}}; A(1).to(); – Jocasta

My solusion is using a unique namespace, in which the anonymous object is assigned to a variable. For simplicity, all the code defined in a macro used as MAP_ADD(mymap,int,int, (1,2)(3,4)); – Jocasta

@MartinWang - Is it possible to pass a pointer to a structure instead of int value? map<int,pointer to a class> instead of map<int,int> in this example? thanks – Affricative

@Affricative you can pass the type of the pointer, what's your point? – Jocasta

@MartinWang - Actually have 2 questions related to this ( I can open another thread if needed ) <br/> Question 1: (seperate issue ) - Unable to use the line <br/> std::map mymap = create_map<int, int >(1,2)(3,4)(5,6); <br/> Question 2 : Would there be any memory leaks if do not clear up the map ? Do we need to add any specific explicit commands to clear up map (free(map))? <br/> Question 3 - Is there any way to expand this as an unique_pointer to a map<int, <unique_ptr>class> <br/> – Affricative

@Affricative 1. show your code and problems. 2. no need to delete/free if no new/malloc used. 3. Arguments of template are types, not specific pointer, I don't get your point. – Jocasta

Let us continue this discussion in chat. – Affricative

Hi nice solution but I thing the map_add_values would be better this way: template <typename MapType> class map_adder { private: MapType &mMap; public: typedef typename MapType::key_type KeyType; typedef typename MapType::mapped_type MappedType; map_adder(MapType& Map):mMap(Map) { } map_adder& operator()(const KeyType& key, const MappedType& val) { mMap[key] = val; return *this; } }; template <typename Maptype> map_adder<Maptype> map_add_values(Maptype& data2change) { return map_adder<Maptype>(data2change); }->map_add_values(mymap)(3,3); – Crowberry

Answer 4

Here is another way that uses the 2-element data constructor. No functions are needed to initialize it. There is no 3rd party code (Boost), no static functions or objects, no tricks, just simple C++:

#include <map>
#include <string>

typedef std::map<std::string, int> MyMap;

const MyMap::value_type rawData[] = {
   MyMap::value_type("hello", 42),
   MyMap::value_type("world", 88),
};
const int numElems = sizeof rawData / sizeof rawData[0];
MyMap myMap(rawData, rawData + numElems);

Since I wrote this answer C++11 is out. You can now directly initialize STL containers using the new initializer list feature:

const MyMap myMap = { {"hello", 42}, {"world", 88} };

Thug

Answer 5

For example:

const std::map<LogLevel, const char*> g_log_levels_dsc =
{
    { LogLevel::Disabled, "[---]" },
    { LogLevel::Info,     "[inf]" },
    { LogLevel::Warning,  "[wrn]" },
    { LogLevel::Error,    "[err]" },
    { LogLevel::Debug,    "[dbg]" }
};

If map is a data member of a class, you can initialize it directly in header by the following way (since C++17):

// Example

template<>
class StringConverter<CacheMode> final
{
public:
    static auto convert(CacheMode mode) -> const std::string&
    {
        // validate...
        return s_modes.at(mode);
    }

private:
    static inline const std::map<CacheMode, std::string> s_modes =
        {
            { CacheMode::All, "All" },
            { CacheMode::Selective, "Selective" },
            { CacheMode::None, "None" }
            // etc
        };
}; 

Respond

In this case in the example, it's better to use std::array – Stavropol

@prehistoricpenguin, why? – Respond

For performance reasons, this function may be a hot point, std::array would be faster than a map look up. – Stavropol

@prehistoricpenguin, could you provide an example with std::array? – Respond

Could you please have a look: quick-bench.com/q/NdDNwTxQaSqEdSoLtehY_dc_ZNQ – Stavropol

Maybe for CPU performance . . . but without knowing the integer value of LogLevel you're taking a risk for memory performance. This enum is going to be terrible in an array. enum LogLevel { Disabled=-100, Info, Warning=500, Error, Debug=32768 }; – Lectionary

Answer 6

I would wrap the map inside a static object, and put the map initialisation code in the constructor of this object, this way you are sure the map is created before the initialisation code is executed.

Nettlesome

I'm with you on this one. It's also a tad faster :) – Columba

Tad faster than what? A global static with an initializer? No, it's not (remember about RVO). – Knut

Nice answer. I would be happy if I see the actual example code – Discant

Answer 7

Just wanted to share a pure C++ 98 work around:

#include <map>

std::map<std::string, std::string> aka;

struct akaInit
{
    akaInit()
    {
        aka[ "George" ] = "John";
        aka[ "Joe" ] = "Al";
        aka[ "Phil" ] = "Sue";
        aka[ "Smitty" ] = "Yando";
    }
} AkaInit;

Neoptolemus

this doesn't work for object without default constructor, insert method should be preferred IMHO – Orinasal

Answer 8

You can try:

std::map <int, int> mymap = 
{
        std::pair <int, int> (1, 1),
        std::pair <int, int> (2, 2),
        std::pair <int, int> (2, 2)
};

Rozamond

You cannot use initializer lists with non-aggregate types before C++11, in which case you may as well use the shorter syntax {1, 2} instead of std::pair<int, int>(1, 2). – Adamsite

Answer 9

If you are stuck with C++98 and don't want to use boost, here there is the solution I use when I need to initialize a static map:

typedef std::pair< int, char > elemPair_t;
elemPair_t elemPairs[] = 
{
    elemPair_t( 1, 'a'), 
    elemPair_t( 3, 'b' ), 
    elemPair_t( 5, 'c' ), 
    elemPair_t( 7, 'd' )
};

const std::map< int, char > myMap( &elemPairs[ 0 ], &elemPairs[ sizeof( elemPairs ) / sizeof( elemPairs[ 0 ] ) ] );

Consistory

Answer 10

This is similar to PierreBdR, without copying the map.

#include <map>

using namespace std;

bool create_map(map<int,int> &m)
{
  m[1] = 2;
  m[3] = 4;
  m[5] = 6;
  return true;
}

static map<int,int> m;
static bool _dummy = create_map (m);

Haland

It probably wouldn't have been copied anyway. – Meit

but this way map couldn't be static const, could it? – Triboluminescence

Answer 11

In addition to the good top answer of using

const std::map<int, int> m = {{1,1},{4,2},{9,3},{16,4},{32,9}}

there's an additional possibility by directly calling a lambda that can be useful in a few cases:

const std::map<int, int> m = []()->auto {
  std::map<int, int> m;
  m[1]=1;
  m[4]=2;
  m[9]=3;
  m[16]=4;
  m[32]=9;
  return m;
}();

Clearly a simple initializer list is better when writing this from scratch with literal values, but it does open up additional possibilities:

const std::map<int, int> m = []()->auto {
  std::map<int, int> m;
  for(int i=1;i<5;++i) m[i*i]=i;
  m[32]=9;
  return m;
}();

(Obviously it should be a normal function if you want to re-use it; and this does require recent C++.)

Dendy

Answer 12

You have some very good answers here, but I'm to me, it looks like a case of "when all you know is a hammer"...

The simplest answer of to why there is no standard way to initialise a static map, is there is no good reason to ever use a static map...

A map is a structure designed for fast lookup, of an unknown set of elements. If you know the elements before hand, simply use a C-array. Enter the values in a sorted manner, or run sort on them, if you can't do this. You can then get log(n) performance by using the stl::functions to loop-up entries, lower_bound/upper_bound. When I have tested this previously they normally perform at least 4 times faster than a map.

The advantages are many fold... - faster performance (*4, I've measured on many CPU's types, it's always around 4) - simpler debugging. It's just easier to see what's going on with a linear layout. - Trivial implementations of copy operations, should that become necessary. - It allocates no memory at run time, so will never throw an exception. - It's a standard interface, and so is very easy to share across, DLL's, or languages, etc.

I could go on, but if you want more, why not look at Stroustrup's many blogs on the subject.

Centeno

Performance is not the only reason for using a map. For example, there are many cases, where you want to link values together (for example, an error code with an error message), and a map makes the use and access relatively simple. But a link to these blog entries may be interesting, maybe I'm doing something wrong. – Deloresdeloria

An array is much easier and has higher performance if you can use it. But if the indices (keys) are not contiguous, and widely spaced, you need a map. – Baese

A map is also a useful form for representing a partial function (function in the mathematical sense; but also, kind of, in the programming sense). An array does not do that. You can't, say, lookup data from an array using a string. – Courtesy

Your answer does not attempt to answer the valid question, and instead speculates on the limitations of the language, proposes solutions to different problems, hence downvote. A real scenario - mapping (continuous or not) library error codes to text strings. With array, search time is O(n), which can be improved by static maping to O(log(n)). – Desma

If indeed "there is no good reason to ever use a static map..." then it is very strange that syntax (initializer lists) that make them easy to use was added in C++11. – Ciaphus

@Tosha: I think the answer addresses your scenario and describes how it could be searched in O(log(n)) without using a map. See Where can I get a “useful” C++ binary search algorithm?. – Googolplex

Valid use case: to feed a static map to code that normally uses a dynamic one. I'm sure there are others. It's usually a good idea to reconsider whenever one finds oneself making a sweeping generalization. – Hernadez