Comment faire pour récupérer toutes les clés (ou des valeurs) d'un std::map et les mettre dans un vecteur?

C'est l'une des voies possibles et je sors:

struct RetrieveKey
{
    template <typename T>
    typename T::first_type operator()(T keyValuePair) const
    {
        return keyValuePair.first;
    }
};

map<int, int> m;
vector<int> keys;

//Retrieve all keys
transform(m.begin(), m.end(), back_inserter(keys), RetrieveKey());

//Dump all keys
copy(keys.begin(), keys.end(), ostream_iterator<int>(cout, "\n"));

Bien sûr, nous pouvons également récupérer toutes les valeurs de la carte par la définition d'un autre foncteur RetrieveValues.

Est-il un autre moyen de réaliser cela facilement? (Je me suis toujours demandé pourquoi std::map ne comprend pas une fonction membre pour nous de le faire.)

  • votre solution est la meilleure...
  • La seule chose que je voudrais ajouter t c'est keys.reserve(m.size());.
InformationsquelleAutor Owen | 2008-09-21
  1. 155

    Alors que votre solution devrait fonctionner, il peut être difficile à lire selon le niveau de compétence de vos collègues programmeurs. En outre, il se déplace de la fonctionnalité loin du site d'appel. Qui peut faire de l'entretien un peu plus difficile.

    Je ne suis pas sûr si votre objectif est de récupérer les clés dans un vecteur ou de les imprimer à cout donc, je suis en train de faire à la fois. Vous pouvez essayer quelque chose comme ceci:

    map<int, int> m;
vector<int> v;
for(map<int,int>::iterator it = m.begin(); it != m.end(); ++it) {
  v.push_back(it->first);
  cout << it->first << "\n";
}

    Ou encore plus simple, si vous utilisez le Boost:

    map<int,int> m;
pair<int,int> me; //what a map<int, int> is made of
vector<int> v;
BOOST_FOREACH(me, m) {
  v.push_back(me.first);
  cout << me.first << "\n";
}

    Personnellement, j'aime le BOOST_FOREACH version car il y a moins de taper et il est très explicite sur ce qu'il fait.

    • Aller chiffres je finirais de retour ici après mes recherche sur Google. La vôtre est la réponse I préférez 🙂
    • Avez-vous réellement travaillé avec BOOST_FOREACH? Le code vous proposons ici, c'est totalement faux
    • Manuel est correct, la syntaxe pour BOOST_FOREACH itération sur une carte est d'abord à définir le type d'élément avec pas de virgule (c'est à dire typedef paire<const int,int> element_type;) alors itérer en utilisant les éléments réels (c'est à dire BOOST_FOREACH(element_type& e, m)
    • c'est une autre façon, mais le coup de pouce docs montrer la spécification de la variable et son type avant la BOOST_FOREACH si le type contient une virgule. Ils montrent également typedefing il. Donc, je suis confus, quel est le problème avec mon code?
    • désolé, je viens de voir votre réponse. Pouvez-vous préciser quel est le problème?
    • votre code n'est pas correct, parce que votre variable est un itérateur. L'ensemble de point de BOOST_FOREACH est que vous n'avez pas besoin d'itérateurs, vous venez de le faire étant donné les éléments les uns après les autres. Voir mon commentaire précédent ou de ce code dump pastie.org/1045222
    • OMG, dès que j'ai lu ta première phrase j'ai claqué ma tête. Merci! Je l'ai corrigé afin de ne pas confondre les futurs visiteurs.
    • Curieux, ne serait-il pas logique de presize le vecteur pour éviter de redimensionner l'allocation?
    • Maintenant, quand C++11 est disponible, la méthode décrite par Juan ci-dessous est mieux à mon avis: //c++0x trop std::map<int,int> mapints; std::vector<int> vints; for(auto imap: mapints) vints.push_back(imap.les premières);
    • N'oubliez pas de faire v.reserve(m.size()) pour éviter d'avoir le vecteur redimensionner pendant le transfert.

    InformationsquelleAutor Jere.Jones
  2. 134
    //c++0x too
std::map<int,int> mapints;
std::vector<int> vints;
vints.reserve(mapints.size());
for(auto const& imap: mapints)
    vints.push_back(imap.first);
    • Il n'y a pas de c++0x numéro de série dans le question.
    • Nice. Oublier it = ...begin(); it != ...end. Plus belle serait la std::map de disposer d'une méthode keys() renvoi de ce vecteur...
    • Il me semble que cette réponse a été donnée à answered Mar 13 '12 at 22:33, qui est de plusieurs mois après C++11 est devenu C++.
    • Bon appel, pas sûr de ce jour, je lisais. Ce n'est pas la partie importante de mon commentaire, de l'esprit; la question a été posée en 2008, afin de C++11 réponse est probablement indésirable! (eh bien, la réponse 4 ans de retard n'est probablement pas d'une grande utilité pour l'interlocuteur...)
    • mais il est d'usage de n'importe qui lisant la question, maintenant, qui est-ce qui DONC est - ce pas seulement d'aider la personne, mais tout le monde.
    • for (auto &imap) est plus précise, car aucune opération de copie.
    • mieux encore, for(auto const & imap : mapints).
    • Je préfère for (auto&& imap : mapints). Voir edmundv.home.xs4all.nl/blog/2014/01/28/...
    • Aussi, certains d'entre nous ont à travailler dans des environnements sans C++11 -_-
    • Si vous prévoyez d'utiliser cette efficace, vous devez ajouter vints.reserve( mapints.size() ); avant la boucle.
    • Personne de l'avenir ici. Concernant @user283145 's commentaire, maintenant C++==C++17 et qui ne durera pas trop longtemps. Moi, j'apprécie quand les réponses spécifier la langue de compatibilité. "C++" est une langue qui a et va continuer à changer.

    InformationsquelleAutor Juan
  3. 57

    Il y a un stimuler la gamme d'adaptateur à cet effet:

    vector<int> keys;
//Retrieve all keys
boost::copy(m | boost::adaptors::map_keys, std::back_inserter(keys));

    Il est similaire map_values gamme d'adaptateur pour extraire les valeurs.

    • Malheureusement, il semble que boost::adaptors n'est pas disponible jusqu'à ce Boost 1.43. L'actuelle version stable de Debian (Squeeze) propose uniquement des Boost de 1,42
    • C'est bien dommage. Boost 1,42 a été publié en Février 2010, plus de 2,5 ans avant de la Serrer.
    • À ce stade, ne pas Presser les Mises à jour ou de les backports repo offrir Boost 1.44?
    • qui boost en-tête est défini dans?
    • Voir le lié doco, il est défini dans boost/range/adaptor/map.hpp
    InformationsquelleAutor Alastair
  4. 42

    C++0x nous a donné une excellente solution:

    std::vector<int> keys;

std::transform(
    m_Inputs.begin(),
    m_Inputs.end(),
    std::back_inserter(keys),
    [](const std::map<int,int>::value_type &pair){return pair.first;});
    • De mon point de vue il n'y a rien de super à ce sujet. std::vector<int> clés; clés.réserve(m_Inputs.size()); for ( auto keyValue : m_Inputs){ touches.push_back(keyValue.les premières); } Est beaucoup mieux que le cryptique transformer. Même en termes de performances. C'est mieux.
    • Vous pouvez réserver la taille des touches, ici aussi, si vous voulez des performances comparables. utiliser la transformation, si vous voulez éviter une boucle for.
    • veux juste ajouter que - pouvez utiliser [](const auto& paire)
    • quel compilateur que vous utilisez? Cette syntaxe n'est pas autorisé ici: 'const auto &": un paramètre ne peut pas avoir un type qui contient 'auto'
    • Visual C++ 2015 mise à Jour 1, fonctionne aussi pour moi avec Visual C++2015 mise à Jour 2
    • auto paramètre lambda est le c++14

    InformationsquelleAutor DanDan
  5. 11

    @DanDan réponse, à l'aide de C++11 est:

    using namespace std;
vector<int> keys;

transform(begin(map_in), end(map_in), back_inserter(keys), 
            [](decltype(map_in)::value_type const& pair) {
    return pair.first;
});

    et à l'aide de C++14 (comme indiqué par @ivan.ukr), nous pouvons remplacer decltype(map_in)::value_type avec auto.

    • Vous pouvez ajouter keys.reserve(map_in.size()); pour plus d'efficacité.
    • Je trouve la méthode de transformation prend plus de code que pour la boucle.
    • const peut être mis derrière le type! J'ai presque l'oublier.
    InformationsquelleAutor James Hirschorn
  6. 10

    La SGI STL a une extension appelée select1st. Dommage qu'il n'est pas dans la norme de la STL!

    InformationsquelleAutor Chris Jester-Young
  7. 9

    Je pense que le BOOST_FOREACH présenté ci-dessus est agréable et propre, cependant, il ya une autre option à l'aide de STIMULER ainsi.

    #include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

std::map<int, int> m;
std::vector<int> keys;

using namespace boost::lambda;

transform(      m.begin(), 
                m.end(), 
                back_inserter(keys), 
                bind( &std::map<int,int>::value_type::first, _1 ) 
          );

copy( keys.begin(), keys.end(), std::ostream_iterator<int>(std::cout, "\n") );

    Personnellement, je ne pense pas que cette approche est aussi propre que le BOOST_FOREACH approche dans ce cas, mais boost::lambda peut être vraiment propre dans les autres cas.

    InformationsquelleAutor paxos1977
  8. 7

    Votre solution est bien, mais vous pouvez utiliser un itérateur pour le faire:

    std::map<int, int> m;
m.insert(std::pair<int, int>(3, 4));
m.insert(std::pair<int, int>(5, 6));
for(std::map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
{
    int key = it->first;
    int value = it->second;
    //Do something
}
    InformationsquelleAutor Brian R. Bondy
  9. 7

    Aussi, si vous avez le coup de pouce, l'utilisation transform_iterator pour éviter de faire une copie temporaire des clés.

    InformationsquelleAutor Marcelo Cantos
  10. 5

    Vous pouvez utiliser le polyvalent boost::transform_iterator. Le transform_iterator permet de transformer l'itéré valeurs, par exemple dans notre cas, lorsque vous voulez traiter uniquement avec les touches, pas de les valeurs. Voir http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

    InformationsquelleAutor amit
  11. 5

    Peu de c++11:

    std::map<uint32_t, uint32_t> items;
std::vector<uint32_t> itemKeys;
for (auto & kvp : items)
{
    itemKeys.emplace_back(kvp.first);
    std::cout << kvp.first << std::endl;
}
    InformationsquelleAutor Rusty Parks
  12. 4

    Le meilleur non-sgi, non-boost, STL solution consiste à étendre la carte::iterator comme suit:

    template<class map_type>
class key_iterator : public map_type::iterator
{
public:
    typedef typename map_type::iterator map_iterator;
    typedef typename map_iterator::value_type::first_type key_type;

    key_iterator(const map_iterator& other) : map_type::iterator(other) {} ;

    key_type& operator *()
    {
        return map_type::iterator::operator*().first;
    }
};

//helpers to create iterators easier:
template<class map_type>
key_iterator<map_type> key_begin(map_type& m)
{
    return key_iterator<map_type>(m.begin());
}
template<class map_type>
key_iterator<map_type> key_end(map_type& m)
{
    return key_iterator<map_type>(m.end());
}

    et ensuite de les utiliser comme:

            map<string,int> test;
        test["one"] = 1;
        test["two"] = 2;

        vector<string> keys;

//     //method one
//     key_iterator<map<string,int> > kb(test.begin());
//     key_iterator<map<string,int> > ke(test.end());
//     keys.insert(keys.begin(), kb, ke);

//     //method two
//     keys.insert(keys.begin(),
//          key_iterator<map<string,int> >(test.begin()),
//          key_iterator<map<string,int> >(test.end()));

        //method three (with helpers)
        keys.insert(keys.begin(), key_begin(test), key_end(test));

        string one = keys[0];
    • Je laisse au lecteur le soin de créer également les const_iterator et d'inverser les itérateurs si/en cas de besoin.
    InformationsquelleAutor Marius
  13. 4

    Voici un joli modèle de fonction à l'aide de C++11 de la magie, de travail pour les std::map, std::unordered_map:

    template<template <typename...> class MAP, class KEY, class VALUE>
std::vector<KEY>
keys(const MAP<KEY, VALUE>& map)
{
    std::vector<KEY> result;
    result.reserve(map.size());
    for(const auto& it : map){
        result.emplace_back(it.first);
    }
    return result;
}

    Découvrez-le ici: http://ideone.com/lYBzpL

    InformationsquelleAutor Clemens Sielaff
  14. 0

    Basé sur @rusty-parcs solution, mais en c++17:

    std::map<uint32_t, uint32_t> items;
std::vector<uint32_t> itemKeys;
for (auto const& [key, std:ignore] : items) {
  itemKeys.emplace_back(key);
}
    InformationsquelleAutor Madiyar
  15. -1

    Un peu similaire à l'un des exemples ici, simplifié à partir de std::map l'utilisation de la perspective.

    template<class KEY, class VALUE>
std::vector<KEY> getKeys(const std::map<KEY, VALUE>& map)
{
    std::vector<KEY> keys(map.size());
    for (const auto& it : map)
        keys.push_back(it.first);
    return keys;
}

    Utiliser comme ceci:

    auto keys = getKeys(yourMap);
    • Hey, je sais que cette réponse est vieux, mais c'est également faux. L'initialisation avec la taille map.size() à-dire le double de la taille de vecteur de retour. Veuillez les corriger, pour sauver quelqu'un d'autre le mal de tête 🙁
    InformationsquelleAutor TarmoPikaro
  16. -2

    (Je me suis toujours demandé pourquoi std::map ne comprend pas une fonction membre pour nous de le faire.)

    Car il ne peut pas faire mieux que ce que vous pouvez faire. Si une méthode de la mise en œuvre sera pas supérieure à un libre de la fonction de la mise en œuvre puis en général, vous ne devriez pas écrire une méthode; vous devez écrire une fonction libre.

    Il n'est également pas immédiatement clair pourquoi il est utile de toute façon.

    • Il y a des raisons autres que l'efficacité d'une bibliothèque de manière à fournir une méthode, comme les "piles" de la fonctionnalité, et d'un ensemble cohérent, encapsulé API. Bien que, certes, aucun de ces termes décrivent la STL particulièrement bien 🙂 Re. ne sait pas pourquoi il est utile -- vraiment? Je pense que c'est assez évident pourquoi la liste des clés est une chose utile pour être en mesure de le faire avec une carte/dict: cela dépend de ce que vous l'utilisez pour.
    • Par ce raisonnement, on devrait pas avoir empty() car il peut être mis en œuvre comme size() == 0.
    • Ce que @gd1 dit. Alors qu'il ne devrait pas y avoir beaucoup de redondance fonctionnelle dans une classe, en insistant sur absolument zéro n'est pas une bonne idée de l'OMI - au moins jusqu'à ce que le C++ permet de "bénir" libre de fonctions de méthodes.
    • Dans les anciennes versions de C++ il y avait des conteneurs pour lesquels empty() et size() pourrait raisonnablement avoir différentes garanties de performance, et je pense que la spécification a été suffisamment lâche pour permettre cela (en particulier, les listes qui ont offert la constante de temps splice()). En tant que tel, le découplage entre eux avait un sens. Je ne pense pas que cette différence est autorisé de plus, cependant.
    • Je suis d'accord. C++ traite std::map<T,U> comme un conteneur de paires. En Python, un dict actes comme de ses clefs quand itéré, mais permet de dire d.items() pour obtenir le C++ comportement. Python fournit également d.values(). std::map<T,U> pourrait certainement fournir une keys() et values() méthode qui retourne un objet qui a begin() et end() qui fournissent des itérateurs sur les clés et les valeurs.
    InformationsquelleAutor DrPizza