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


449

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

Ответы:


620

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

115
Каждый раз, когда я вижу что-то подобное с C ++, я думаю обо всем ужасном шаблонном коде, который должен быть за этим. Хороший пример!
Грег Хьюгилл,

34
Прелесть всего ужасного шаблонного кода, который реализует эти утилиты, в том, что он аккуратно инкапсулирован в библиотеке, и конечному пользователю редко приходится иметь дело со сложностью.
Стив Гуиди

45
@QBziZ: Если ваша компания отказывается от использования Boost на том основании, что она недостаточно «стандартна», мне интересно, какая библиотека C ++ будет «достаточно стандартной». Повышение является стандартным компаньоном для кодера C ++.
DevSolar

47
Моя проблема с Boost (здесь и в других местах) заключается в том, что вы часто можете обходиться без него (в данном случае с C ++ 11 или до C ++ 11 с функцией ). Boost значительно увеличивает время компиляции, имеет множество файлов для хранения в вашем хранилище (и для копирования в / zip / extract, если вы делаете архив). Вот почему я стараюсь не использовать его. Я знаю, что вы можете выбирать, какие файлы включать / не включать, но обычно вам не нужно беспокоиться о взаимозависимостях Boost с самим собой, поэтому вы просто копируете все это.
Бобобо

7
Моя проблема с Boost заключается в том, что он часто имеет несколько новых библиотечных зависимостей, что обычно означает БОЛЕЕ пакеты, которые необходимо установить для корректной работы. Нам уже нужен libstdc ++. Например, библиотека Boost ASIO требует как минимум 2 новые библиотеки (возможно, больше), которые необходимо установить. C ++ 11/14 намного облегчает отсутствие необходимости в Boost.
Рахли

135

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

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

18
Почему это «лучший»? Почему, например, это лучше, чем ответ @ Dreamer?
Маркиз Лорн

6
Я думаю, что это «лучше», потому что это действительно просто и не зависит от других существующих структур (таких как Boost :: Assign или его повторная реализация). И по сравнению с ответом @ Dreamer, ну, я избегаю создавать целую структуру только для инициализации карты ...
PierreBdR

3
Обратите внимание, что здесь есть опасность . externпеременные не будут иметь своих правильных значений в этом «перед главным конструктором времени выполнения», если компилятор только видел externобъявление, но еще не столкнулся с фактическим определением переменной .
Бобобо

5
Нет, опасность состоит в том, что нет ничего говорящего о том, в каком порядке должны быть инициализированы статические переменные (по крайней мере, в единицах компиляции). Но это не проблема, связанная с этим вопросом. Это общая проблема со статическими переменными.
PierreBdR

5
нет повышения И нет C ++ 11 => +1. Обратите внимание, что функцию можно использовать для инициализации const map<int,int> m = create_map()(и, таким образом, инициализировать константные члены класса в списке инициализации:struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : m(create_map())
ribamar

115

Это не сложная задача сделать что-то похожее на повышение. Вот класс с тремя функциями, включая конструктор, для воспроизведения того, что сделал 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 здесь: 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 <int, int> my_map;
// Позже где-нибудь вдоль кода
map_add_values ​​<Int, Int> (my_map) (1,2) (3,4) (5,6);

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

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


3
Я использую ваш первый пример как <int, string>, чтобы связать номера ошибок (из перечисления) с сообщениями - это работает как талисман - спасибо.
Слэшмаис

1
operator[]принимает только один аргумент.
Dalle

1
@dalle: Хороший улов! Я почему-то думал, что перегруженные операторы [] могут принимать больше.
Vite Falcon

2
Это фантастический ответ. Обидно, что ОП ни разу не выбрал. Вы заслуживаете мега реквизита.
Томас Торогуд

map_add_values ​​не работает в gcc, который жалуется: error: conflicting declaration ‘map_add_values<int, int> my_map’ error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’
Martin Wang

42

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

25

Например:

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

Если map является членом данных класса, вы можете инициализировать его непосредственно в заголовке следующим образом (начиная с 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
        };
}; 

24

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


1
Я с тобой в этом. Это также немного быстрее :)
QBziZ

2
Чуть быстрее чем что? Глобальная статика с инициализатором? Нет, это не так (помните про RVO).
Павел Минаев

7
Хороший ответ. Я был бы счастлив, если бы я увидел фактический пример кода
Sungguk Lim

18

Просто хотел поделиться чистой работой 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;

2
это не работает для объекта без конструктора по умолчанию, метод вставки должен быть предпочтительным ИМХО
Алессандро Теруцци

16

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

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

1
Вы не можете использовать списки инициализаторов с неагрегированными типами до C ++ 11, и в этом случае вы можете также использовать более короткий синтаксис {1, 2}вместо std::pair<int, int>(1, 2).
Ферруччо

9

Это похоже 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);

12
Это, вероятно, не было бы скопировано в любом случае.
GManNickG

2
но эта карта не может быть статической константой, не так ли?
xmoex

6

Если вы застряли с 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 ] ) ] );

-4

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

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

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

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

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


8
Производительность - не единственная причина использования карты. Например, во многих случаях вы хотите связать значения вместе (например, код ошибки с сообщением об ошибке), а карта делает использование и доступ относительно простым. Но ссылка на эти записи в блоге может быть интересной, может я что-то не так делаю.
MatthiasB

5
Массив намного проще и имеет более высокую производительность, если вы можете его использовать. Но если индексы (ключи) не являются смежными и широко расставленными, вам нужна карта.
KarlU

1
A mapтакже является полезной формой для представления частичной функции (функция в математическом смысле; но также, в некотором смысле, в смысле программирования). Массив не делает этого. Вы не можете, скажем, искать данные из массива, используя строку.
einpoklum

3
Ваш ответ не пытается ответить на действительный вопрос, а вместо этого размышляет об ограничениях языка, предлагает решения различных проблем, следовательно, отрицательный голос. Реальный сценарий - отображение (непрерывных или нет) кодов ошибок библиотеки в текстовые строки. Для массива время поиска равно O (n), что можно улучшить статическим сопоставлением с O (log (n)).
Тоша

2
Если действительно «нет веской причины использовать статическую карту ...», то очень странно, что в C ++ 11 был добавлен синтаксис (списки инициализаторов), облегчающий их использование.
ellisbben
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.