Initialiser une static std :: map <int, int> en C ++

Question

Quelle est la bonne manière d’initialiser une carte statique ? Avons-nous besoin d’une fonction statique qui initialisera il ?

Answer 1

À l’aide de C ++11 :

À l’aide de Boost.Assign:

Answer 2

Le meilleur moyen est d'utiliser une fonction:

 #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

Ce n'est pas un problème compliqué à faire quelque chose de similaire pour booster. Voici une classe avec seulement trois fonctions, y compris le constructeur, de reproduire ce que boost n'a (presque).

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

Utilisation:

std::map mymap = create_map<int, int >(1,2)(3,4)(5,6);

Le code ci-dessus fonctionne le mieux pour l'initialisation des variables globales ou des membres statiques d'une classe qui doit être initialisé et que vous n'avez aucune idée de quand il est utilisé en premier, mais vous voulez vous assurer que les valeurs sont disponibles.

Si par exemple, vous avez pour insérer des éléments dans un std::map... en voici une autre classe pour vous.

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

Utilisation:

typedef std::map<int, int> Int2IntMap;
Int2IntMap testMap;
map_add_values<Int2IntMap>(1,2)(3,4)(5,6).to(testMap);

Le voir en action avec GCC 4.7.2 ici: http://ideone.com/3uYJiH

############### TOUT EN DESSOUS DE CE QUI EST OBSOLÈTE #################

EDIT: L' map_add_values de la classe ci-dessous, qui était à l'origine de la solution que j'avais proposé, serait un échec quand il s'agit de GCC 4.5+. S'il vous plaît regardez le code ci-dessus pour savoir comment ajouter des valeurs à la carte existante.

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

Utilisation:

std::map<int, int> my_map;
// Puis, quelque part le long du code
map_add_values<int,int>(my_map)(1,2)(3,4)(5,6);

NOTE: Précédemment, j'ai utilisé un operator [] pour l'ajout de la valeur réelle. Ce n'est pas possible a fait observer que dalle.

##################### FIN DE L'OBSOLESCENCE DE LA SECTION #####################

Answer 4

Voici une autre façon qui utilise le constructeur 2-élément de données. Aucuns fonctions ne sont nécessaires pour l’initialiser. Il n’y a aucun code de la partie 3 (Boost), aucun C++ statique fonctions ou d’objets, pas de trucs, tout simple :

Depuis que j’ai écrit cette réponse C ++11 est sorti. Vous pouvez initialiser maintenant directement les conteneurs STL à l’aide de la nouvelle fonctionnalité de liste d’initialiseurs :

Answer 5

J’envelopper la carte à l’intérieur d’un objet statique et mettre le code d’initialisation de carte dans le constructeur de cet objet, de cette façon vous êtes sûr que la carte est créée avant l’exécution du code d’initialisation.