std::map default-Wert

Nein, gibt es nicht. Die einfachste Lösung ist, ein eigenes zu schreiben Kostenlose Vorlage-Funktion, dies zu tun. So etwas wie:

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

Zweck: Konto für Allgemeine assoziative Container, sowie optional Komparator und-Zuweisung-Parameter.

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

InformationsquelleAutor der Antwort

Den C++ - standard (23.3.1.2) gibt an, dass der neu eingefügte Wert ist Standard gebaut, so map selbst ist nicht ein Weg, es zu tun. Ihre Auswahlmöglichkeiten sind:

• Geben Sie den Wert, geben Sie einen default-Konstruktor, initialisiert es den Wert, den Sie wollen, oder
• Wickeln Sie die Karte in Ihre eigene Klasse, bietet ein Standard-Wert und implementiert operator[] zu legen, dass Standard.

InformationsquelleAutor der Antwort Mike Seymour

Allgemeinere Version, die Unterstützung von C++98/03 und Mehr Container

Arbeitet mit generischen assoziative Container, die nur template-parameter ist der container-Typ selbst.

Unterstützten Container: std::mapstd::multimapstd::unordered_mapstd::unordered_multimapwxHashMapQMapQMultiMapQHashQMultiHashetc.

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

Verwendung:

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

Hier ist eine ähnliche Umsetzung durch die Verwendung einer wrapper-Klasse, die ist ähnlich wie die Methode get() von dict Typ in 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);
}

Verwendung:

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

InformationsquelleAutor der Antwort jyw

C++17 try_emplace die genau das tut. Es nimmt einen Schlüssel und eine Liste von Argumenten für die Wert-Konstruktor und gibt ein paar: ein iterator und ein bool.: http://en.cppreference.com/w/cpp/container/map/try_emplace

InformationsquelleAutor der Antwort Ben

Vielleicht können Sie geben einen benutzerdefinierten Zuweisung die Zuweisung mit einem Standard-Wert, den Sie wollen.

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

InformationsquelleAutor der Antwort VDVLeon