Инициализация статической std::map<int, int> в C++

Лучший способ создать карту — использовать функцию:

#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();

В этом примере мы определяем функцию create_map, которая создает и заполняет карту значениями. Затем мы вызываем эту функцию и присваиваем результат переменной m. Это делает код более организованным и позволяет легко изменять содержимое карты в одном месте.

Не является сложной задачей создать что-то подобное boost. Вот класс с тремя функциями, включая конструктор, который почти полностью воспроизводит функциональность boost.

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;
    }
};

Применение:

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

Этот код лучше всего подходит для инициализации глобальных переменных или статических членов класса, которые должны быть инициализированы, и вы не знаете, когда они будут использованы впервые, но хотите гарантировать, что значения будут доступны.

Если вам нужно вставить элементы в существующий std::map, вот еще один класс для вас.

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());
    }
};

Применение:

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

Вы можете увидеть это в действии с GCC 4.7.2 здесь: ideone.com.

############### ВСЁ НИЖЕ - УСТАРЕВШЕ #################

ИСПРАВЛЕНИЕ: Класс map_add_values, представленный ниже, который был первоначальным решением, которое я предложил, не будет работать в GCC 4.5+. Пожалуйста, смотрите код выше о том, как добавлять значения в существующий 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;
    }
};

Применение:

std::map<int, int> my_map;
// Позже где-то в коде
map_add_values<int,int>(my_map)(1,2)(3,4)(5,6);

ЗАМЕТКА: Ранее я использовал оператор [] для добавления фактических значений. Это невозможно, как замечено пользователем dalle.

##################### КОНЕЦ УСТАРЕВШЕЙ СЕКЦИИ #####################

Вот еще один способ, который использует конструктор данных с 2 элементами. Не требуется никаких функций для его инициализации. Здесь нет стороннего кода (Boost), статических функций или объектов, никаких уловок — только простой 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);

С тех пор, как я написал этот ответ, уже вышел стандарт C++11. Теперь вы можете напрямую инициализировать контейнеры STL, используя новую возможность списков инициализации:

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

Если у вас есть std::map, который является членом класса, вы можете инициализировать его напрямую в заголовочном файле следующим образом (начиная с C++17):

// Пример

template<>
class StringConverter<CacheMode> final
{
public:
    static auto convert(CacheMode mode) -> const std::string&
    {
        // валидация...
        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" }
            // и т.д.
        };
}; 

В этом примере мы используем static inline для объявления и инициализации членов класса в заголовочном файле. Это позволяет избежать проблем с множественным определением при включении заголовка в нескольких cpp-файлах.

Я бы обернул карту в статический объект и поместил код инициализации карты в конструктор этого объекта. Таким образом, вы будете уверены, что карта создана до выполнения кода инициализации.