¿Cómo recuperar todas las claves (o valores) de un std :: map y ponerlas en un vector?

Question

Ésta es una de las posibles formas que salen:

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")); 

Por supuesto, también podemos recuperar todos los valores del mapa mediante la definición de otro funtor RetrieveValues ​​.

¿Hay alguna otra manera de lograr esto fácilmente? (Siempre me pregunto por qué std :: map no incluye una función de miembro para que lo hagamos).

Answer 1

Si bien su solución debería funcionar, puede ser difícil de leer dependiendo del nivel de habilidad de sus compañeros programadores. Además, aleja la funcionalidad del sitio de llamadas. Lo cual puede hacer que el mantenimiento sea un poco más difícil.

No estoy seguro de si su objetivo es obtener las claves en un vector o imprimirlas para cout así que estoy haciendo ambas cosas. Usted puede intentar algo como esto:

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

O aún más simple, si está utilizando 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"; 
} 

Personalmente, me gusta la versión BOOST_FOREACH porque hay menos escribir y es muy explícito acerca de lo está haciendo.

Answer 2

El SGI STL tiene una extensión llamada select1st. Lástima que no está en STL estándar.

Answer 3

Su solución está muy bien, pero se puede utilizar un repetidor para hacerlo:

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 
} 

Answer 4

Además, si usted tiene Boost, el uso transform_iterator para evitar hacer una copia temporal de las llaves.

Answer 5

Puede usar el versátil boost :: transform_iterator. Transform_iterator le permite transformar los valores iterados, por ejemplo, en nuestro caso, cuando desea tratar únicamente con las claves, no con los valores. Consulte http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Answer 6

Creo que BOOST_FOREACH presentado arriba es agradable y limpio, sin embargo, hay otra opción que también usa BOOST.

#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")); 

Personalmente, no creo este enfoque es tan limpio como el enfoque BOOST_FOREACH en este caso, pero boost :: lambda puede ser muy limpio en otros casos.

Answer 7

(siempre estoy preguntando por qué std :: mapa no incluye una función miembro para que lo hagamos.)

Debido a que no puede hacerlo mejor que se puede hacer . Si la implementación de un método no será superior a la implementación de una función gratuita, entonces, en general, no debe escribir un método; deberías escribir una función gratuita.

Tampoco está claro de inmediato por qué es útil de todos modos.

Answer 8

La mejor solución no SGI, no impulso STL es ampliar mapa :: iterador de esta manera:

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

y luego usarlos como tan:

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

Answer 9

C++ 0x nos ha dado una excelente solución adicional,:

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

Answer 10

Hay una boost range adaptor para este propósito:

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

Hay un adaptador de rango map_values ​​similar para extraer los valores.

Answer 11

//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); 

Answer 12

Poco de un C++ 11 toma:

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

Answer 13

Aquí está una plantilla de función agradable usando C++ 11 magia, trabajando tanto para std :: mapa, 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; 
} 

Échale un vistazo aquí: http://ideone.com/lYBzpL

Answer 14

@ respuesta de DanDan, usando C++ 11 es:

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

y usando C++ 14 (como se indica por @ ivan.ukr) podemos reemplazar decltype(map_in)::value_type con auto.