Copiar valores de mapa a vector en STL

Question

Trabajando en mi camino a través de STL efectivo en este momento. El ítem 5 sugiere que, por lo general, es preferible usar funciones de miembros de rango para sus contrapartidas de elemento único. Actualmente deseo copiar todos los valores en un mapa (es decir, no necesito las claves) a un vector.

¿Cuál es la forma más limpia de hacer esto?

Answer 1

No se puede usar fácilmente un rango aquí porque el iterador que se obtiene de un mapa se refiere a std :: pair, donde los iteradores que se usarían para insertar en un vector se refieren a un objeto del tipo almacenado en el vector, que es (si está descartando la clave) no un par.

Realmente no creo que se hace mucho más limpio que lo obvio:

#include <map> 
#include <vector> 
#include <string> 
using namespace std; 

int main() { 
    typedef map <string, int> MapType; 
    MapType m; 
    vector <int> v; 

    // populate map somehow 

    for(MapType::iterator it = m.begin(); it != m.end(); ++it) { 
     v.push_back(it->second); 
    } 
} 

la que yo probablemente volver a escribir como una función de plantilla si iba a utilizar más de una vez. Algo así como:

template <typename M, typename V> 
void MapToVec(const M & m, V & v) { 
    for(typename M::const_iterator it = m.begin(); it != m.end(); ++it) { 
     v.push_back(it->second); 
    } 
} 

Answer 2

Probablemente se podría utilizar std::transform para ese propósito. Tal vez prefiera la versión de Neils, dependiendo de lo que sea más legible.

---

Ejemplo de xtofl (ver comentarios):

#include <map> 
#include <vector> 
#include <algorithm> 
#include <iostream> 

template< typename tPair > 
struct second_t { 
    typename tPair::second_type operator()(const tPair& p) const { return  p.second; } 
}; 

template< typename tMap > 
second_t< typename tMap::value_type > second(const tMap& m) { return second_t<  typename tMap::value_type >(); } 


int main() { 
    std::map<int,bool> m; 
    m[0]=true; 
    m[1]=false; 
    //... 
    std::vector<bool> v; 
    std::transform(m.begin(), m.end(), std::back_inserter(v), second(m)); 
    std::transform(m.begin(), m.end(), std::ostream_iterator<bool>(std::cout,  ";"), second(m)); 
} 

muy genérica, recuerde que darle crédito si le resulta útil.

Answer 3

Una forma es utilizar funtor:

template <class T1, class T2> 
    class CopyMapToVec 
    { 
    public: 
     CopyMapToVec(std::vector<T2>& aVec): mVec(aVec){} 

     bool operator() (const std::pair<T1,T2>& mapVal) const 
     { 
      mVec.push_back(mapVal.second); 
      return true; 
     } 
    private: 
     std::vector<T2>& mVec; 
    }; 


int main() 
{ 
    std::map<std::string, int> myMap; 
    myMap["test1"] = 1; 
    myMap["test2"] = 2; 

    std::vector<int> myVector; 

    //reserve the memory for vector 
    myVector.reserve(myMap.size()); 
    //create the functor 
    CopyMapToVec<std::string, int> aConverter(myVector); 

    //call the functor 
    std::for_each(myMap.begin(), myMap.end(), aConverter); 
} 

Answer 4

Esto es lo que yo haría.
También usaría una función de plantilla para facilitar la construcción de select2nd.

#include <map> 
#include <vector> 
#include <algorithm> 
#include <memory> 
#include <string> 

/* 
* A class to extract the second part of a pair 
*/ 
template<typename T> 
struct select2nd 
{ 
    typename T::second_type operator()(T const& value) const 
    {return value.second;} 
}; 

/* 
* A utility template function to make the use of select2nd easy. 
* Pass a map and it automatically creates a select2nd that utilizes the 
* value type. This works nicely as the template functions can deduce the 
* template parameters based on the function parameters. 
*/ 
template<typename T> 
select2nd<typename T::value_type> make_select2nd(T const& m) 
{ 
    return select2nd<typename T::value_type>(); 
} 

int main() 
{ 
    std::map<int,std::string> m; 
    std::vector<std::string> v; 

    /* 
    * Please note: You must use std::back_inserter() 
    *    As transform assumes the second range is as large as the first. 
    *    Alternatively you could pre-populate the vector. 
    * 
    * Use make_select2nd() to make the function look nice. 
    * Alternatively you could use: 
    * select2nd<std::map<int,std::string>::value_type>() 
    */ 
    std::transform(m.begin(),m.end(), 
        std::back_inserter(v), 
        make_select2nd(m) 
       ); 
} 

Answer 5

El uso de lambdas uno puede realizar lo siguiente:

{ 
    std::map<std::string,int> m; 
    std::vector<int> v; 
    v.reserve(m.size()); 
    std::for_each(m.begin(),m.end(), 
       [&v](const std::map<std::string,int>::value_type& p) 
       { v.push_back(p.second); }); 
} 

Answer 6

Si está utilizando el boost libraries, puede usar boost :: bind para acceder al segundo valor del par de la siguiente manera:

#include <string> 
#include <map> 
#include <vector> 
#include <algorithm> 
#include <boost/bind.hpp> 

int main() 
{ 
    typedef std::map<std::string, int> MapT; 
    typedef std::vector<int> VecT; 
    MapT map; 
    VecT vec; 

    map["one"] = 1; 
    map["two"] = 2; 
    map["three"] = 3; 
    map["four"] = 4; 
    map["five"] = 5; 

    std::transform(map.begin(), map.end(), 
        std::back_inserter(vec), 
        boost::bind(&MapT::value_type::second,_1)); 
} 

Esta solución se basa en una publicación de Michael Goldshteyn en el boost mailing list.

Answer 7

pensé que debería ser

std :: transformar (map.begin(), map.end(), std :: back_inserter (VEC), boost :: bind (& MAPt :: value_type :: primero, _1));

Answer 8

Por qué no:

template<typename K, typename V> 
std::vector<V> MapValuesAsVector(const std::map<K, V>& map) 
{ 
    std::vector<V> vec; 
    vec.reserve(map.size()); 
    std::for_each(std::begin(map), std::end(map), 
     [&vec] (const std::map<K, V>::value_type& entry) 
     { 
      vec.push_back(entry.second); 
     }); 
    return vec; 
} 

uso:

vec auto = MapValuesAsVector (anymap);

Answer 9

Pregunta anterior, nueva respuesta.Con C++ 11 tenemos el nuevo lujo para el bucle:

for (const auto &s : schemas) 
    names.push_back(s.first); 

donde esquemas es una std::map y los nombres es una std::vector.

Esto rellena la matriz (nombres) con claves del mapa (esquemas); cambie s.first a s.second para obtener una matriz de valores.

Answer 10

#include <algorithm> // std::transform 
#include <iterator> // std::back_inserter 
std::transform( 
    your_map.begin(), 
    your_map.end(), 
    std::back_inserter(your_values_vector), 
    [](auto &kv){ return kv.second;} 
); 

Disculpa que no he añadido ninguna explicación. Creo que el código es tan simple que no requiere ninguna explicación. Así :

transform(beginInputRange, endInputRange, outputIterator, unaryOperation) 

Esta función llama unaryOperation en cada artículo de inputIterator gama (beginInputRange-endInputRange). El valor de la operación se almacena en outputIterator.

Si queremos operar a través de un mapa completo, utilizamos map.begin() y map.end() como nuestro rango de entrada. Queremos almacenar nuestros valores de mapa en vector, por lo que debemos usar back_inserter en nuestro vector: back_inserter(your_values_vector). El back_inserter es un outputIterator especial que empuja los nuevos elementos al final de la colección dada (como parámetro). El último parámetro es unaryOperation - toma solo un parámetro - value de InputIterator. Entonces podemos usar lambda: [](auto &kv) { [...] }, donde & kv es solo una referencia al par del elemento del mapa. Así que si queremos volver sólo valores de los elementos del mapa podemos simplemente volver kv.second:

[](auto &kv) { return kv.second; } 

Creo que esto explica las dudas.