Populate an STL map with two arrays (C++)

It does not work for me, I am using GCC 4.2.4 it is failing in compilation with error

error: template instantiation depth exceeds maximum of 200 (use -ftemplate-depth-NN to increase the maximum) instantiating ‘void MapMaker<KeyType, ValueType, N>::fill_pair() [with unsigned int pos = 4294967117u, KeyType = std::basic_string<char, std::char_traits<char>, std::allocator<char> >, ValueType = unsigned char, unsigned int N = 20u]

I tried to use this piece of code where i want to instantiate a static map of size 20.

Have you made any changes to the fill_pair() member function?

The mapmaker class relies on compile-time recursion to populate an array of "pairs". I wonder if any modifications you may have made to this have caused it to overflow (Judging by the compiler error, it looks like you may have removed the 'terminating' member function, which is fill_pair<0>() - this is the member function which halts the compile time recursion)

template<int pos> void fill_pair()
    {
        table[pos].first = keys[pos];
        table[pos].second = vals[pos];
        fill_pair<pos-1>();
    }

    template<> void fill_pair<0>()
    {
        table[0].first = keys[0];
        table[0].second = vals[0];
    }

My first question is why is static used? My understanding is that static objects are instantiated once and persist untill the end of the program and that by default namespace variables inlcuding the global namespace are implicity static. This is some neat code and I'm trying to understand it.

> My first question is why is static used?
> My understanding is that static objects are instantiated once and persist untill the end of the program

In this particular case specifying a static storage duration does not make any perceptible difference.

int main()
{
    int a[] = { 7, 8, 9 } ; // automatic storage duration; a exists till main returns

    // static storage duration; b exists till end of program - ie. till main returns
    static int b[] = { 7, 8, 9 } ;

    // because b is a POD type placed in the SDA, and initialized with compile-time 
    // constants, it does not require dynamic initialization. a does.
}

In C++0x, we could just use its uniform initialization syntax via std::initializer_list<>.
With C++98, using Boost::Assign is equally nifty. http://www.boost.org/doc/libs/1_43_0/libs/assign/doc/index.html

#include <map>
#include <string>

#if __cplusplus > 199711L // C++0x
    #include <initializer_list>
#else // C++98
    #include <boost/assign/list_of.hpp>
#endif // C++0x

int main()
{
    #if __cplusplus > 199711L // C++0x

    std::map< int, std::string > map =
         { {9,"sheep"},{2,"cow"},{3,"horse"},{0,"chicken"},{5,"dog"} } ;

    #else // C++98

    std::map< int, std::string > map = boost::assign::map_list_of
                (9,"sheep")(2,"cow")(3,"horse")(0,"chicken")(5,"dog") ;

    #endif // C++0x
}

Can I assume the same with const? Variables defined as const can not be changed later in the program. But because this is a snippet and a quick visual inspect shows that the variables are not changed, const does not have an effect on the program.

In this simple case, const doesn't have an effect on the program in terms of the code generated. The compiler can easily figure out that the variables are not changed.

However, it is still a good idea to always use 'const' where ever appropriate; it is just programming hygiene, and it's worth making it a habit.