Wie alle Schlüssel (oder Werte) von einer std :: map abgerufen und in einen Vektor eingefügt werden?

Question

Dies ist einer der möglichen Wege, ich komme aus:

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

Natürlich können wir auch alle Werte aus der Karte abrufen, indem RetrieveValues ​​eine andere Funktors definieren.

Gibt es einen anderen Weg, um dies leicht zu erreichen? (Ich frage mich immer, warum std :: map für uns keine Member-Funktion enthält.)

Answer 1

Während Ihre Lösung funktionieren sollte, kann es schwierig sein, sie zu lesen, abhängig vom Können Ihrer Mitprogrammierer. Außerdem wird die Funktionalität von der Aufrufsite entfernt. Das kann die Wartung etwas erschweren.

Ich bin mir nicht sicher, ob es Ihr Ziel ist, die Schlüssel in einen Vektor zu bekommen oder sie zu drucken, damit ich beides mache. Sie können so etwas wie dies versuchen:

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

Oder noch einfacher, wenn Sie Boost sind:

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

Persönlich mag ich die BOOST_FOREACH Version, weil es weniger tippen und es ist sehr deutlich, was es tut.

Answer 2

Die SGI STL hat eine Erweiterung namens select1st. Schade, es ist nicht in Standard-STL!

Answer 3

Ihre Lösung ist in Ordnung, aber Sie einen Iterator, es zu tun verwenden können:

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

Auch wenn Sie Boost-haben, verwenden transform_iterator zu vermeiden, dass eine temporäre Kopie des Schlüssels.

Answer 5

Sie können den vielseitigen boost :: transform_iterator verwenden. Der transform_iterator ermöglicht es Ihnen, die iterierten Werte zu transformieren, beispielsweise in unserem Fall, wenn Sie nur mit den Schlüsseln arbeiten möchten, nicht mit den Werten. Siehe http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Answer 6

Ich denke, der BOOST_FOREACH oben ist schön und sauber, aber es gibt eine andere Option mit BOOST auch.

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

Ich persönlich glaube nicht, dieser Ansatz so sauber wie der BOOST_FOREACH Ansatz ist in diesem Fall, aber boost :: Lambda kann in anderen Fällen wirklich sauber sein.

Answer 7

(ich frage mich immer, warum std :: map keine Memberfunktion enthält für uns, dies zu tun.)

Weil es nicht besser machen können als Sie es tun können . Wenn die Implementierung einer Methode der Implementierung einer freien Funktion nicht überlegen ist, sollten Sie im Allgemeinen keine Methode schreiben; Sie sollten eine freie Funktion schreiben.

Es ist auch nicht sofort klar, warum es sowieso nützlich ist.

Answer 8

Der beste Nicht-sgi, nicht-Boost-STL-Lösung ist wie so map :: Iterator zu verlängern:

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

und dann nutzen sie etwa so:

 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 hat uns eine weitere, sehr gute Lösung gegeben:

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

Es gibt eine boost range adaptor für diesen Zweck:

Es gibt einen ähnlichen map_values ​​Bereich Adapter zum Extrahieren der Werte.

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

Bit eines C++ 11 nehmen:

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

Hier ist eine nette Funktion Vorlage mit C++ 11 Magie, die sich für beide 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; 
} 

bestellen hier aus: http://ideone.com/lYBzpL

Answer 14

@ DanDan Antwort, C++ 11:

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

und C++ 14 unter Verwendung von (wie von @ ivan.ukr angegeben) wir decltype(map_in)::value_type mit auto ersetzen können.