Como recuperar todas as chaves (ou valores) de um std :: map e colocá-las em um vetor?

Esta é uma das maneiras possíveis de sair:

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

Obviamente, também podemos recuperar todos os valores do mapa, definindo outro functor RetrieveValues .

Existe alguma outra maneira de conseguir isso facilmente? (Estou sempre me perguntando por que std :: map não inclui uma função de membro para fazer isso.)

Embora sua solução funcione, pode ser difícil de ler, dependendo do nível de habilidade de seus colegas programadores. Além disso, ele afasta a funcionalidade do site de chamada. O que pode dificultar um pouco a manutenção.

Não tenho certeza se o seu objetivo é colocar as chaves em um vetor ou imprimi-las para que eu faça as duas coisas. Você pode tentar algo como isto:

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

Ou ainda mais simples, se você estiver usando o 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";
}

Pessoalmente, gosto da versão BOOST_FOREACH porque há menos digitação e é muito explícito sobre o que está fazendo.

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

Existe um adaptador de faixa de reforço para este fim:

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

Existe um adaptador de intervalo map_values ​​semelhante para extrair os valores.

O C ++ 0x nos deu uma solução excelente e excelente:

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

A resposta de @ DanDan, usando 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;
}); 

e usando C ++ 14 (como observado por ivan.ukr), podemos substituir decltype(map_in)::value_typepor auto.

O SGI STL tem um ramal chamado select1st. Pena que não está no STL padrão!

Sua solução é boa, mas você pode usar um iterador para fazer isso:

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
}

Baseado na solução @ rusty-parks, mas em c ++ 17:

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

for (const auto e [tecla, ignorada]: itens)
{
    itemKeys.push_back (key);
}

Eu acho que o BOOST_FOREACH apresentado acima é agradável e limpo, no entanto, há outra opção usando o BOOST também.

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

Pessoalmente, não acho que essa abordagem seja tão limpa quanto a abordagem BOOST_FOREACH nesse caso, mas o boost :: lambda pode ser realmente limpo em outros casos.

Além disso, se você tiver o Boost, use transform_iterator para evitar fazer uma cópia temporária das chaves.

Um pouco de uma captura de c ++ 11:

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

Você pode usar o versátil boost :: transform_iterator. O transform_iterator permite transformar os valores iterados, por exemplo, no nosso caso, quando você deseja lidar apenas com as chaves, não com os valores. Consulte http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Aqui está um bom modelo de função usando magia C ++ 11, trabalhando para 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;
}

Confira aqui: http://ideone.com/lYBzpL

A melhor solução STL sem sgi e sem boost é estender o map :: iterator da seguinte forma:

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

e depois use-os assim:

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

Com exemplo de mapa atômico

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

Um pouco semelhante a um dos exemplos aqui, simplificado da std::mapperspectiva do uso.

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

Use assim:

auto keys = getKeys(yourMap);

(Estou sempre me perguntando por que std :: map não inclui uma função de membro para fazer isso.)

Porque ele não pode fazer isso melhor do que você pode fazê-lo. Se a implementação de um método não for superior à implementação de uma função livre, em geral você não deve escrever um método; você deve escrever uma função livre.

Também não está claro imediatamente por que ele é útil.