стандартное значение std :: map

Question

Есть ли способ указать значение по умолчанию std::map s operator[] возвращается, когда ключ не существует?

Answer 1

Нет, нет. Самое простое решение - написать собственную бесплатную шаблонную функцию для этого. Что-то вроде:

#include <string>
#include <map>
using namespace std;

template <typename K, typename V>
V GetWithDef(const  std::map <K,V> & m, const K & key, const V & defval ) {
   typename std::map<K,V>::const_iterator it = m.find( key );
   if ( it == m.end() ) {
      return defval;
   }
   else {
      return it->second;
   }
}

int main() {
   map <string,int> x;
   ...
   int i = GetWithDef( x, string("foo"), 42 );
}

---

C ++ 11 Обновление

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

template <template<class,class,class...> class C, typename K, typename V, typename... Args>
V GetWithDef(const C<K,V,Args...>& m, K const& key, const V & defval)
{
    typename C<K,V,Args...>::const_iterator it = m.find( key );
    if (it == m.end())
        return defval;
    return it->second;
}

Answer 2

Хотя это не совсем отвечает на вопрос, я обошел проблему с таким кодом:

struct IntDefaultedToMinusOne
{
    int i = -1;
};

std::map<std::string, IntDefaultedToMinusOne > mymap;

Answer 3

Стандарт C ++ (23.3.1.2) определяет, что вновь добавленное значение создается по умолчанию, поэтому само по себе map не обеспечивает способ сделать это. Ваш выбор:

• Дайте типу значения конструктор по умолчанию, который инициализирует его желаемым значением, или
• Оберните карту в свой собственный класс, который предоставляет значение по умолчанию и реализует operator[] для вставки этого значения по умолчанию.

Answer 4

Более общая версия, поддержка C ++ 98/03 и более контейнеров

Работает с общими ассоциативными контейнерами, единственным параметром шаблона является сам тип контейнера.

Поддерживаемые контейнеры: std::map, std::multimap, std::unordered_map, std::unordered_multimap, wxHashMap, QMap, QMultiMap, QHash, QMultiHash и т. Д.

template<typename MAP>
const typename MAP::mapped_type& get_with_default(const MAP& m, 
                                             const typename MAP::key_type& key, 
                                             const typename MAP::mapped_type& defval)
{
    typename MAP::const_iterator it = m.find(key);
    if (it == m.end())
        return defval;

    return it->second;
}

Использование:

std::map<int, std::string> t;
t[1] = "one";
string s = get_with_default(t, 2, "unknown");

---

Вот аналогичная реализация с использованием класса-оболочки, который больше похож на метод get() типа dict в Python: https://github.com/hltj/wxMEdit/blob/master/src/xm/xm_utils.hpp

template<typename MAP>
struct map_wrapper
{
    typedef typename MAP::key_type K;
    typedef typename MAP::mapped_type V;
    typedef typename MAP::const_iterator CIT;

    map_wrapper(const MAP& m) :m_map(m) {}

    const V& get(const K& key, const V& default_val) const
    {
        CIT it = m_map.find(key);
        if (it == m_map.end())
            return default_val;

        return it->second;
    }
private:
    const MAP& m_map;
};

template<typename MAP>
map_wrapper<MAP> wrap_map(const MAP& m)
{
    return map_wrapper<MAP>(m);
}

Использование:

std::map<int, std::string> t;
t[1] = "one";
string s = wrap_map(t).get(2, "unknown");

Answer 5

template<typename T, T X>
struct Default {
    Default () : val(T(X)) {}
    Default (T const & val) : val(val) {}
    operator T & () { return val; }
    operator T const & () const { return val; }
    T val;
};

<...>

std::map<KeyType, Default<ValueType, DefaultValue> > mapping;

Answer 6

C ++ 17 обеспечивает try_emplace, что делает именно это. Он принимает ключ и список аргументов для конструктора значения и возвращает пару: iterator и bool .: http://en.cppreference.com/w/cpp/container/map/try_emplace

Answer 7

Нет способа указать значение по умолчанию - это всегда значение, созданное по умолчанию (конструктор нулевого параметра).

Фактически operator[], вероятно, делает больше, чем вы ожидаете, так как если значение для данного ключа на карте не существует, он вставит новое значение со значением из конструктора по умолчанию.

Answer 8

Один из способов - использовать map::at() вместо []. Если ключ не существует, at выдает исключение. Еще приятнее, это также работает для векторов и, следовательно, подходит для общего программирования, где вы можете поменять карту с вектором.

Использование пользовательского значения для незарегистрированного ключа может быть опасным, так как это пользовательское значение (например, -1) может быть обработано далее в коде. За исключением, легче обнаружить ошибки.

Answer 9

Значение инициализируется с помощью конструктора по умолчанию, как говорят другие ответы. Однако полезно добавить, что в случае простых типов (целочисленных типов, таких как int, float, pointer или POD (планируемые старые данные)), значения инициализируются нулями (или обнуляются при инициализации значений (что эффективно то же самое), в зависимости от того, какая версия C ++ используется).

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

std::map<int, char*> map;
typedef char *P;
char *p = map[123],
    *p1 = P(); // map uses the same construct inside, causes zero-initialization
assert(!p && !p1); // both will be 0

См. Есть ли в скобках после имени типа разница с новым? для более подробной информации по этому вопросу.

Answer 10

Может быть, вы можете указать пользовательский распределитель, который выделит желаемое значение по умолчанию.

template < class Key, class T, class Compare = less<Key>,
       class Allocator = allocator<pair<const Key,T> > > class map;