Jak pobrać wszystkie klucze (lub wartości) ze std :: map i umieścić je w wektorze?

To jeden z możliwych sposobów, w jaki wychodzę:

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

Oczywiście możemy również pobrać wszystkie wartości z mapy, definiując kolejny funktor RetrieveValues .

Czy jest jakiś inny sposób na osiągnięcie tego łatwo? (Zawsze zastanawiam się, dlaczego std :: map nie zawiera dla nas funkcji członka).

Chociaż twoje rozwiązanie powinno działać, może być trudne do odczytania, w zależności od poziomu umiejętności innych programistów. Dodatkowo przenosi funkcjonalność z dala od strony połączeń. Co może utrudnić konserwację.

Nie jestem pewien, czy twoim celem jest wprowadzenie kluczy do wektora lub wydrukowanie ich, aby zrobić to, więc robię oba. Możesz spróbować czegoś takiego:

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

Lub nawet prościej, jeśli używasz wzmocnienia:

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

Osobiście podoba mi się wersja BOOST_FOREACH, ponieważ jest mniej pisania i jest bardzo wyraźna na temat tego, co robi.

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

Jest to adapter zakres impuls do tego celu:

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

Istnieje podobny adapter zakresu map_values ​​do wyodrębniania wartości.

C ++ 0x dał nam kolejne doskonałe rozwiązanie:

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

Odpowiedź DanDana przy użyciu C ++ 11 brzmi:

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

i przy użyciu C ++ 14 (jak wskazano przez @ ivan.ukr) może zastąpić decltype(map_in)::value_typez auto.

SGI STL ma rozszerzenie o nazwie select1st. Szkoda, że ​​nie ma go w standardowym STL!

Twoje rozwiązanie jest w porządku, ale możesz to zrobić za pomocą iteratora:

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
}

Oparty na rozwiązaniu @ rusty-parks, ale w c ++ 17:

std :: map <int, int> items;
std :: vector <int> itemKeys;

for (const auto & [key, ignored]: items)
{
    itemKeys.push_back (klucz);
}

Myślę, że BOOST_FOREACH przedstawiony powyżej jest ładny i czysty, jednak istnieje również inna opcja korzystania z 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") );

Osobiście nie sądzę, aby to podejście było tak czyste jak podejście BOOST_FOREACH w tym przypadku, ale boost :: lambda może być naprawdę czyste w innych przypadkach.

Ponadto, jeśli masz Boost, użyj transform_iterator, aby uniknąć tworzenia tymczasowej kopii kluczy.

Trochę c ++ 11 wziąć:

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

Możesz użyć uniwersalnego boost :: transform_iterator. Transform_iterator pozwala na przekształcenie iterowanych wartości, na przykład w naszym przypadku, gdy chcesz zajmować się tylko kluczami, a nie wartościami. Zobacz http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Oto ładny szablon funkcji wykorzystujący magię C ++ 11, działający zarówno dla 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;
}

Sprawdź to tutaj: http://ideone.com/lYBzpL

Najlepszym rozwiązaniem STL innym niż sgi, nie doładowującym jest rozszerzenie map :: iterator w następujący sposób:

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

a następnie użyj ich w następujący sposób:

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

Z przykładem mapy atomowej

#include <iostream>
#include <map>
#include <vector> 
#include <atomic>

using namespace std;

typedef std::atomic<std::uint32_t> atomic_uint32_t;
typedef std::map<int, atomic_uint32_t> atomic_map_t;

int main()
{
    atomic_map_t m;

    m[4] = 456;
    m[2] = 45678;

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

    return 0;
}

Nieco podobny do jednego z przykładów tutaj, uproszczony z std::mapperspektywy użytkowania.

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

Użyj w ten sposób:

auto keys = getKeys(yourMap);

(Zawsze zastanawiam się, dlaczego std :: map nie zawiera dla nas funkcji członka).

Ponieważ nie może tego zrobić lepiej niż ty. Jeśli implementacja metody nie będzie lepsza niż implementacja wolnej funkcji, to na ogół nie powinieneś pisać metody; powinieneś napisać darmową funkcję.

Nie jest też od razu jasne, dlaczego jest to przydatne.