Obtention d'une liste de valeurs à partir d'une carte

Est-il un stl façon d'obtenir une liste de valeurs à partir d'une carte?

je.e, j'ai:

std::map<A,B> myMap;

et je voudrais une fonction qui retourne simplement la liste de valeurs, j'.e, std::list<B> (ou qui que ce soit.
Est-il intégré dans la stl façon de le faire?

Double de Copie les valeurs de la carte de vecteur dans la STL
Pas d'accord avec le dup en raison de l'OMI, de la accepté de répondre n'est pas ce que je considère être le meilleur choix de conception.
En fait, cela ne change pas au fait de cette question un doublon, il signifie simplement que vous devez répondre à la première question, plutôt que de le deuxième afin d'éviter la dispersion des réponses à toutes les cours. J'aime votre réponse ici.

OriginalL'auteur Amir Rachum | 2010-11-16

  1. 15

    Un map élément est défini comme un map::value_type, et le type de c'est un pair<A,B>. first est la clé et second est la valeur. Vous pouvez écrire un foncteur pour extraire second à partir d'un value_type, et copie dans un vector (ou un list, ou ce que vous voulez.) La meilleure façon de faire la copie est d'utiliser transform, qui fait exactement ce que son nom l'indique: il prend une valeur d'un type et le transforme en un autre type de valeur.

    Ici est un exemple de travail:

    #include <cstdlib>
#include <map>
#include <string>
#include <algorithm>
#include <iterator>
#include <vector>
#include <iostream>
using namespace std;

typedef map<unsigned, string> MyMap;
MyMap my_map;

struct get_second : public std::unary_function<MyMap::value_type, string>
{
    string operator()(const MyMap::value_type& value) const
    {
        return value.second;
    }
};

int main()
{
    my_map[1] = "one";
    my_map[2] = "two";
    my_map[3] = "three";
    my_map[4] = "four";
    my_map[5] = "five";

    //get a vector of values
    vector<string> my_vals;
    transform(my_map.begin(), my_map.end(), back_inserter(my_vals), get_second() );

    //dump the list
    copy( my_vals.begin(), my_vals.end(), ostream_iterator<string>(cout, "\n"));
}

    EDIT:

    Si vous avez un compilateur qui prend en charge le C++0x les lambdas, vous pouvez éliminer le foncteur entièrement. Ceci est très utile pour rendre le code plus lisible et plus, soutenir, plus facile à maintenir car vous ne finissent pas avec des dizaines de petits one-off foncteurs flottant autour dans votre base de code. Voici comment vous pourriez modifier le code ci-dessus pour utiliser une lambda:

    transform(my_map.begin(), my_map.end(), back_inserter(my_vals), [](const MyMap::value_type& val){return val.second;} );

    OriginalL'auteur John Dibling

  2. 2

    L'un des nombreux "built-in" des moyens est bien sûr le plus évident. Juste itérer sur toutes les paires d'éléments, qui sont commandés par clé (pair::first), et ajouter de la valeur (pair::second) dans un nouveau conteneur, ce qui vous permet de construire avec la bonne capacité de se débarrasser de l'excès d'allocations au cours de l'itération et l'ajout d'.

    Juste une remarque: std::list est rarement le conteneur que vous souhaitez utiliser. À moins, bien sûr, vous avez vraiment, vraiment ne besoin de ses caractéristiques spécifiques.

    OriginalL'auteur Johann Gerell

  3. 2

    Il n'y a rien de construit dans, pas. Il est assez simple d'écrire votre propre fonction, si: Itérer sur la carte. L'itérateur vous donnera un pair<A, B>. Ajouter chaque second de la valeur à la liste des résultats.

    Je considère transform et l'idée de foncteurs être plus ou moins intégrée
    en disant "construite en," j'interprète la question de la demande PHP array_values ou Perl values — la bibliothèque fournit une fonction précisément adaptés à la tâche plutôt que juste un tas de pièces que vous avez à mettre ensemble pour écrire un values fonction de votre propre. Les choses sont encore pire si votre compilateur de bibliothèque ou de ne pas fournir à tous les meilleurs morceaux (comme select2nd ou lambda).

    OriginalL'auteur Rob Kennedy

  4. 2

    Vous ne pouvez pas simplement "obtenir" une telle liste, car il n'y a pas de pré-existante de la liste stockée n'importe où dans les tripes, mais vous pouvez en construire un:

    typedef std::map<A,B> myMapType;
myMapType myMap;
std::list<B> valueList;
for (myMapType::const_iterator it=myMap.begin(); it!=myMap.end(); ++it) {
  valueList.push_back( it->second );
}

    Ou si vous aimez vraiment le plus TSL façon:

    class GetSecond {
  template<typename T1, typename T2>
  const T2& operator()( const std::pair<T1,T2>& key_val ) const
    { return key_val.second; }
};

typedef std::map<A,B> myMapType;
myMapType myMap;
std::list<B> valueList;
std::transform(myMap.begin(), myMap.end(), std::back_inserter(valueList),
               GetSecond());
    Malheureusement, il n'y a pas de select2nd dans la Norme C++ de la Bibliothèque.
    Ouais, j'ai remarqué trop tard. Je suis sur le point de cesser de s'embêter avec le fameux SGI "documentation".

    OriginalL'auteur aschepler

  5. 1

    Sûr.

    std::list<B> list;
std::for_each(myMap.begin(), myMap.end(), [&](const std::pair<const A, B>& ref) {
    list.push_back(ref.second);
});

    Si vous n'avez pas de compilateur C++0x, d'abord, vous avez ma sympathie, et deuxièmement, vous aurez besoin de construire rapidement un objet de fonction à cet effet.

    Où est la std::transform l'amour?
    Quelque chose de mal avec l'amour une bonne lambda?
    les lambdas sont au-delà de le domaine, car cette question n'est pas balisé [c++0x]
    Néanmoins, je vais ammend ma réponse à inclure un lamda exemple
    Dibling: soutien de Lambda cessé d'avoir à être explicitement marqués lors de la MSVC10 et GCC4.5 à la fois les soutenir.

    OriginalL'auteur Puppy

  6. 0

    Vous pouvez utiliser de boost transform_iterator: http://www.boost.org/doc/libs/1_64_0/libs/iterator/doc/transform_iterator.html

    struct GetSecond {
template <typename K, typename T>
const T& operator()(const std::pair<K, T> & p) const { return p.second; }
template <typename K, typename T>
T& operator()(std::pair<K, T> & p) const { return p.second; }
};
template <typename MapType>
auto begin_values(MapType& m) -> decltype(boost::make_transform_iterator(m.begin(), GetSecond())) {
return boost::make_transform_iterator(m.begin(), GetSecond());
}
template <typename MapType>
auto end_values(MapType& m) -> decltype(boost::make_transform_iterator(m.end(), GetSecond())) {
return boost::make_transform_iterator(m.end(), GetSecond());
}
template <typename MapType>
struct MapValues {
MapType & m;
MapValues(MapType & m) : m(m) {}
typedef decltype(begin_values(m)) iterator;
iterator begin() { return begin_values(m); }
iterator end() { return end_values(m); }
};
template <typename MapType>
MapValues<MapType> get_values(MapType & m) {
return MapValues<MapType>(m);
}
int main() {
std::map<int, double> m;
m[0] = 1.0;
m[10] = 2.0;
for (auto& x : get_values(m)) {
std::cout << x << ',';
x += 1;
}
std::cout << std::endl;
const std::map<int, double> mm = m;
for (auto& x : get_values(mm)) {
std::cout << x << ',';
}
std::cout << std::endl;
}

    OriginalL'auteur Ben