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

Question

Как правильно инициализировать статическую карту? Нужна ли нам статическая функция, которая ее инициализирует?

Answer 1

Используя C++11:

#include <map>
using namespace std;

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

Использование 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');

Answer 2

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

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

Answer 3

Это не сложная задача сделать что-то похожее на повышение. Вот класс, в котором всего три функции, включая конструктор, для воспроизведения того, что сделал 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(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 здесь: http://ideone.com/3uYJiH

############### ВСЕ НИЖЕ ЭТО ОБОЗРЕНИЕ #################

РЕДАКТИРОВАТЬ: map_add_values Класс ниже, который был оригинальным решением, которое я предложил, потерпит неудачу, когда дело доходит до GCC 4.5+. Пожалуйста, посмотрите на код выше, как добавить значения в существующую карту.

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 my_map;
// Позже где-нибудь вдоль кода
map_add_values ​​(my_map)(1,2)(3,4)(5,6);

ПРИМЕЧАНИЕ: ранее я использовал operator [] для добавления фактических значений. Это невозможно, как прокомментировал Далле.

##################### ОКОНЧАТЕЛЬНЫЙ РАЗДЕЛ #####################

Answer 4

Вот еще один способ, который использует 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} };

Answer 5

Например:

const std::map<LoggerLevel, const char*> g_logLevelsDescriptions =
{
    { LoggerLevel::llNothing, "Logging disabled"            },
    { LoggerLevel::llInfo,    "Base information"            },
    { LoggerLevel::llWarn,    "Warnings"                    },
    { LoggerLevel::llError,   "Errors"                      },
    { LoggerLevel::llDebug,   "All information: debug-mode" }
};

Answer 6

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

Answer 7

Просто хотел поделиться чистой C++ 98 вокруг:

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

Answer 8

Ты можешь попробовать:

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

Answer 9

Если вы застряли в C++98 и не хотите использовать boost, здесь есть решение, которое я использую, когда мне нужно инициализировать статическую карту:

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 ] ) ] );

Answer 10

Это похоже на PierreBdRбез копирования карты.

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

Answer 11

В дополнение к хорошему верхнему ответу использования

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

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

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

Очевидно, что при написании этого с нуля с буквальными значениями лучше использовать простой список инициализаторов, но он открывает дополнительные возможности:

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

(Очевидно, это должна быть обычная функция, если вы хотите использовать ее повторно; и для этого требуется последняя версия C++.)

Answer 12

У вас есть несколько очень хороших ответов здесь, но я для меня, это похоже на случай "когда все, что вы знаете, это молоток"...

Самый простой ответ на вопрос, почему не существует стандартного способа инициализации статической карты, - нет веской причины когда-либо использовать статическую карту...

Карта - это структура, предназначенная для быстрого поиска неизвестного набора элементов. Если вы знаете элементы заранее, просто используйте C-массив. Введите значения отсортированным образом или выполните сортировку по ним, если вы не можете этого сделать. Затем вы можете получить производительность log(n), используя stl::functions для зацикливания записей, lower_bound/upper_bound. Когда я проверял это ранее, они обычно работают как минимум в 4 раза быстрее, чем карта.

Преимущества многократно... - более высокая производительность (*4, я измерял на многих типах процессоров, всегда около 4) - более простая отладка. Просто проще увидеть, что происходит с линейным макетом. - Тривиальные реализации операций копирования, если это станет необходимым. - Он не выделяет память во время выполнения, поэтому никогда не выдаст исключение. - Это стандартный интерфейс, поэтому его очень легко обменивать, библиотеки DLL или языки и т. Д.

Я мог бы продолжить, но если вы хотите больше, почему бы не посмотреть на многочисленные блоги Страуструпа на эту тему.