std :: map valeur par défaut

Question

Existe-t-il un moyen de spécifier la valeur par défaut std::map renvoie operator[] lorsqu'une clé n'existe pas?

Answer 1

Non, il n'y en a pas. La solution la plus simple consiste à écrire votre propre fonction de modèle gratuit pour ce faire. Quelque chose comme:

#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 Mise à jour

Objet: compte pour les conteneurs associatifs génériques, ainsi que des paramètres de comparaison et allocateur en option.

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

Il est impossible de spécifier la valeur par défaut - elle est toujours construite par défaut (constructeur de paramètre zéro). En fait, operator[] fait probablement plus que ce à quoi vous vous attendez, comme si une valeur n'existait pas pour la clé donnée dans la carte, elle en insère une nouvelle avec la valeur du constructeur par défaut.

Answer 3

Peut-être que vous pouvez donner un allocateur personnalisé qui allouer avec une valeur par défaut que vous voulez.

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

Answer 4

La norme C++ (23.3.1.2) indique que la valeur nouvellement insérée est construit par défaut, de sorte que map lui-même ne fournit pas un moyen de le faire. Vos choix sont:

• Donnez la valeur de type un constructeur par défaut qui initialise à la valeur que vous voulez, ou
• Enveloppez la carte dans votre propre classe qui fournit une valeur par défaut et met en œuvre operator[] pour insérer cette valeur par défaut.

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

La valeur est initialisé à l'aide du constructeur par défaut, comme disent les autres réponses. Cependant, il est utile d'ajouter que dans le cas de types simples (types entiers tels que int, float, pointeur ou POD (plan old data)), les valeurs sont initialisées à zéro (ou initialisées par initialisation de valeur (qui est effectivement la même chose), selon la version de C++ utilisée). Quoi qu'il en soit, la ligne de fond est que les cartes avec des types simples initialiseront automatiquement les nouveaux éléments automatiquement. Ainsi, dans certains cas, il n'est pas nécessaire de spécifier explicitement la valeur initiale par défaut.

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 

Voir Do the parentheses after the type name make a difference with new? pour plus de détails sur la question.

Answer 7

version plus générale, le soutien C de 98/03 et Plus de conteneurs

Fonctionne avec des conteneurs associatifs génériques, le seul paramètre de modèle est le type de conteneur lui-même.

conteneurs pris en charge: std::map, std::multimap, std::unordered_map, std::unordered_multimap, wxHashMap, QMap, QMultiMap, QHash, QMultiHash, etc.

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

Utilisation:

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

---

Voici une implémentation similaire en utilisant une classe wrapper, qui est plus similaire à la méthode get() de type dict en 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); 
} 

Utilisation:

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

Answer 8

Bien que cela ne répond pas exactement à la question, j'ai contourné le problème avec le code comme ceci:

struct IntDefaultedToMinusOne 
{ 
    int i = -1; 
}; 

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

Answer 9

C++ 17 fournit try_emplace qui fait exactement cela. Il faut une clé et une liste d'arguments pour le constructeur de valeur et retourne une paire: une iterator et un bool. http://en.cppreference.com/w/cpp/container/map/try_emplace