Le stockage mst carte dans la carte

J'ai pour stocker des std::map comme valeur dans std::map

std::map< std::string, std::map<std::string, std::string> > someStorage;

Comment les insérer dans la deuxième(intérieure) de la carte? J'ai essayé avec:

someStorage.insert( std::make_pair("key", std::make_pair("key2", "value2")) );

Mais cela jette un grand nombre d'erreurs. Quel est le problème?

  • Pouvez-vous modifier pour être plus précis que "jette un grand nombre d'erreurs"?
InformationsquelleAutor Max Frai | 2010-12-18
  1. 40

    Essayer:

    std::map< std::string, std::map<std::string, std::string> > someStorage;

someStorage["Hi"]["This Is Layer Two"] = "Value";
    • C'est inutilement COÛTEUX, car il crée une chaîne par défaut puis réassigne à la valeur passée dans. La meilleure approche est de savoir comment Foncé Falcon l'a fait: stackoverflow.com/questions/4479017/storing-std-map-in-map/... - je pense que vous devez être voté jusqu'à ces jours en raison de votre compte de points et non pas la qualité de vos réponses. Je souhaite que les gens prennent le temps de lire, de penser à vos réponses.
    • J'aime ma réponse parce que c'est le plus facile à lire. Frais est rarement un facteur, maintenance est un coût réel. Ce code est le plus facile à maintenir. PS. Également la copie d'une chaîne est à peu près aussi cher que la copie d'un couple d'entiers (comme most std::string implémentations utilise une copie sur écriture approche et donc la chaîne n'est pas fait de copie).
    • Quel est le coût de la création d'une chaîne par défaut et ensuite l'affectation d'un char const* - t-il ? La valeur par défaut std::string probablement de performance aucune allocation de mémoire (si vôtre, tirer hors de votre bibliothèque fournisseur), et puis il y a std::string& std::string::operator=(char const*), et bien sûr, si la chaîne existe déjà, alors vous éviter d'avoir à construire un temporaire std::string qui ne sera pas inséré de toute façon... I pense que vous êtes d'être inutilement snappy ces jours-ci.
    • Je ne suis pas particulièrement intéressé par la lutte se passe ici -- mais gardez à l'esprit que votre réponse ci-dessus n'est pas sémantiquement équivalent à insert qu'il va remplacer une valeur qui est déjà là alors que insert ne sera pas. Ce qui est préférable dépend du contexte, bien sûr-mais la question de départ, dans ce cas ne semblent poser pour insert.
    • En effet, contrairement à l'affaire au point, ce que j'ai dit et ce que vous avez dit est sémantiquement équivalentes 🙂
    • Golodetz: De reformuler: insert() ne modifie pas la valeur si elle existe déjà, alors que le code ci-dessus permet de changer la valeur. (Traduit de l'PhDish en anglais pour le reste d'entre nous). 🙂
    • Touché 😉 je suppose que le problème a été "n'est pas sémantiquement équivalents", qui se traduit par "ne pas avoir le même sens que". Des excuses pour parler dans bizarre de Doctorat langues 🙂
    • Supprimé, désolé-aucun délit prévu. Étais juste curieux de savoir quand vous avez dit est tout.
    • L'impact sur les performances est négligeable, au mieux, avec C++03. Avec C++11 et la sémantique de déplacement de ses encore moins relvant. La chose que vous devez penser maintenant, c'est le temps d'utiliser std::map ou std::unordered_map.

    InformationsquelleAutor Martin York
  2. 22
    someStorage["key"].insert(std::make_pair("key2", "value2")));

    Si vous avez toujours voulu utiliser l'insérer sur la face extérieure de la carte en tant que bien, ici, c'est une façon de le faire

    std::map<std::string, std::string> inner;
inner.insert(std::make_pair("key2", "value2"));
someStorage.insert(std::make_pair("key", inner));
    • Cela seul n'est pas suffisant. Où est la carte en la valeur créée?
    • Vous vous rendez compte que someStorage["clé"] est-ce un insert si nécessaire, à l'aide d'un défaut initialisé à la valeur? (en d'autres termes, une carte vide est associée à la clé si la clé n'existe pas)
    • Vous ne devez pas utiliser make_pair. Vous êtes en supposant que la mise en œuvre utilise la paire. Utilisation std::map<Key, Value>::value_type il est typedefed exactement pour cette raison.
    • Au contraire: le C++0x standard dit: "Pour une map<Key,T> le key_type est la Clé et la value_type est la paire<const Clé,T>." (23.4.1.2)
    • Falcon: Oui, exactement. C'est pourquoi vous devez utiliser value_type et pas make_pair.
    • Le peu qu'il a cité est, par essence, une garantie spécifique de la norme que les deux sont équivalents. En d'autres termes, make_pair est toujours garanti pour fonctionner ici (et pour ce que ça vaut, c'est les expressions idiomatiques, lorsqu'il fait un insert dans mon expérience).
    • Golodetz: @Dark Falcon: Oui. Je comprends que. Mais que pensez-vous du type retourné par make_pair est? Comme un indice ce n'est pas le même que value_type parce que "key1", "key2", "valeur2" ne sont pas std::les chaînes de caractères! Vous êtes lucking sur un couple de conversions implicites. En utilisant value_type que vous obtenez le bon type sans avoir à vous soucier de le compilateur de faire toutes les conversions implicites. Dans mon équipe (probablement à l'échelle de l'entreprise): make_pair est retiré à la révision du code de temps. Ici value_type est idiomatiques (parce que c'est le type stockées dans la carte).
    • Je suis conscient qu'il y a des conversions implicites de passe -- ils sont souhaitables, de mon point de vue, parce que le code avec make_pair peut souvent être plus lisible. Si ils vous causer un problème de performances (vous profilés, je suppose), alors bien sûr, c'est juste assez pour l'utiliser value_type. Mais sinon, je ne vois pas un avantage majeur. Supposons que votre carte est std::map<VeryLongKeyTypeName,VeryLongValueTypeName> m;, vous seriez certainement voulez éviter d'écrire m.insert(std::map<VLKTN,VLVTN>::value_type(k,v)); quand vous pourriez écrire m.insert(std::make_pair(k,v)); -- ce dernier est beaucoup plus clair.
    • J'accepte que vous pourriez utiliser un typedef, mais c'est plus embêtant pour ce qui est dans la plupart des cas, peu ou pas d'avantages. Et si votre type de carte dépend des paramètres de modèle, alors vous finissez par avoir à ajouter de typename avant std::map<K,V>::value_type à chaque fois. Vous pourriez faire typedef typename std::map<K,V>::value_type MapVal; et puis m.insert(MapVal(k,v));, bien sûr, mais je ne vois pas l'avantage réel.
    • Je l'aurais fait: typedef std::map<VeryLongKeyTypeName,VeryLongValueTypeName> Storage; Puis son m.insert(Storage::value_type(key,value)); Qui est beaucoup plus propre et plus lisible. Le coût de la conversion implicite n'est pas la question (je suis sûr que les optimisations du compilateur rendrait pratiquement le même). La conversion implicite est problématique, car il n'est pas toujours évident de savoir ce qui se passe (il vous arrive d'avoir de la chance dans le std::string est très bien testé en ce qui concerne, tout autre type défini par l'utilisateur, je serais beaucoup plus méfiant de ce qui se passe (et donc besoin de passer du temps à vérifier)).
    • Le problème ici n'est pas lorsque vous l'écrire. Parce que vous savez comment votre code de travail. Mais le problème vient de maintenir le code. Si tout les types de changé (et cela arrive souvent) les conversions implicites pouvez commencer à causer d'énormes problèmes. Par Exemple Key1 est le changement d'un std::string en Application::Key1 ce type de changement en cascade à travers le programme. En utilisant le bon type la première fois de prévenir les problèmes. À l'aide de make_pair avec tous les associés (en sus des conversions de type (il y en aura toujours quelques-uns mais essayer et minimiz)), il faudra beaucoup plus de vérification.
    • Si par exemple VeryLongKeyTypeName est un paramètre du modèle, il finirait par être typename Storage::value_type(key, value) bien sûr, parce que value_type serait encore un type de charge. (Tout en décidant comment répondre pour le reste, l'ours avec moi... :))
    • Aussi loin que les conversions implicites en aller, il me semble que le vrai problème se trouve avec des gens qui se permettent des conversions implicites qu'ils ne devraient pas. Par défaut, j'aurais tendance à faire plus seul paramètre constructeurs explicit sauf si particulier, j'ai été l'intention de permettre la conversion implicite. (J'avais aussi dans l'objectif d'éviter imprudent d'opérateurs de conversion, par exemple l'octroi de operator const char* pour un type de chaîne.) Si seulement sensible conversions implicites sont pris en charge, je ne vois pas pourquoi il devrait y avoir un problème majeur.
    • Je pense que la ligne de fond est que je ne pense pas que cela fait une grande quantité de différence -- le value_type façon implique potentiellement une inutiles typedef, et est un peu plus compliqué, mais rend les types impliqués plus explicite. Le make_pair est un peu plus pratique. Si utilisé correctement, je ne pense pas que ce soit doit causer de réels problèmes. (J'ai changé les principaux types de cartes avant, et je n'ai jamais eu un problème avec les conversions implicites.) YMMV - je suppose que je n'aurais pas un problème majeur avec l'utilisation value_type si j'ai travaillé dans l'une de vos équipes, mais je ne pense pas qu'il achète vraiment très bien.
    • Golodetz: Bien de sortir des arguments. Bonne chance avec la viva.
    • Comment pourrait-on construire une carte comprenant à la fois des valeurs primitives et de la carte à l'intérieur d'une carte, quelque chose comme ci-dessous { 'Cle1': '1', 'Cle2': { 'a' : '2', 'b' : '3', 'c' : { 'd' : '3', 'e' : '1' } } }
    • Cela seul n'est pas suffisant. Où est la carte en la valeur créée?
    • Vous vous rendez compte que someStorage["clé"] est-ce un insert si nécessaire, à l'aide d'un défaut initialisé à la valeur? (en d'autres termes, une carte vide est associée à la clé si la clé n'existe pas)
    • Vous ne devez pas utiliser make_pair. Vous êtes en supposant que la mise en œuvre utilise la paire. Utilisation std::map<Key, Value>::value_type il est typedefed exactement pour cette raison.
    • Au contraire: le C++0x standard dit: "Pour une map<Key,T> le key_type est la Clé et la value_type est la paire<const Clé,T>." (23.4.1.2)
    • Falcon: Oui, exactement. C'est pourquoi vous devez utiliser value_type et pas make_pair.
    • Le peu qu'il a cité est, par essence, une garantie spécifique de la norme que les deux sont équivalents. En d'autres termes, make_pair est toujours garanti pour fonctionner ici (et pour ce que ça vaut, c'est les expressions idiomatiques, lorsqu'il fait un insert dans mon expérience).
    • Golodetz: @Dark Falcon: Oui. Je comprends que. Mais que pensez-vous du type retourné par make_pair est? Comme un indice ce n'est pas le même que value_type parce que "key1", "key2", "valeur2" ne sont pas std::les chaînes de caractères! Vous êtes lucking sur un couple de conversions implicites. En utilisant value_type que vous obtenez le bon type sans avoir à vous soucier de le compilateur de faire toutes les conversions implicites. Dans mon équipe (probablement à l'échelle de l'entreprise): make_pair est retiré à la révision du code de temps. Ici value_type est idiomatiques (parce que c'est le type stockées dans la carte).
    • Je suis conscient qu'il y a des conversions implicites de passe -- ils sont souhaitables, de mon point de vue, parce que le code avec make_pair peut souvent être plus lisible. Si ils vous causer un problème de performances (vous profilés, je suppose), alors bien sûr, c'est juste assez pour l'utiliser value_type. Mais sinon, je ne vois pas un avantage majeur. Supposons que votre carte est std::map<VeryLongKeyTypeName,VeryLongValueTypeName> m;, vous seriez certainement voulez éviter d'écrire m.insert(std::map<VLKTN,VLVTN>::value_type(k,v)); quand vous pourriez écrire m.insert(std::make_pair(k,v)); -- ce dernier est beaucoup plus clair.
    • J'accepte que vous pourriez utiliser un typedef, mais c'est plus embêtant pour ce qui est

    InformationsquelleAutor Dark Falcon
  3. 4

    Une carte a une méthode d'insertion qui accepte une paire clé/valeur. Votre clé est de type chaîne, ce qui n'est pas un problème, mais votre valeur est pas de type paire (qui vous générez), mais de type de carte. Donc, vous avez besoin de stocker une carte complète comme valeur ou vous modifiez la carte initiale de définition d'accepter une paire comme valeur.

    InformationsquelleAutor TToni
  4. 3

    //Essayez ceci:

    std::map< std::string, std::map<std::string, std::string> > myMap;

myMap["key one"]["Key Two"] = "Value";
myMap["Hello"]["my name is"] = "Value";

    //Imprimer la carte:

    for( map<string,map<string,string> >::const_iterator ptr=myMap.begin();ptr!=myMap.end(); ptr++) {
    cout << ptr->first << "\n";
    for( map<string,string>::const_iterator eptr=ptr->second.begin();eptr!=ptr->second.end(); eptr++){
        cout << eptr->first << " " << eptr->second << endl;

    }

}
    InformationsquelleAutor Gelo
  5. 0

    Vous pouvez également utiliser la liste d'initialisation: 

    someStorage.insert( std::make_pair("key", std::map<std::string, std::string> {std::make_pair("key2", "value2")}) );
    InformationsquelleAutor Roma Pavlov