Bagaimana cara mengambil semua kunci (atau nilai) dari std :: map dan memasukkannya ke dalam vektor?

Ini adalah salah satu cara yang mungkin saya lakukan:

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

Tentu saja, kita juga dapat mengambil semua nilai dari peta dengan mendefinisikan functor lain RetrieveValues .

Apakah ada cara lain untuk mencapai ini dengan mudah? (Saya selalu bertanya-tanya mengapa std :: map tidak menyertakan fungsi anggota untuk kita lakukan.)

Walaupun solusi Anda harusnya berhasil, bisa jadi sulit untuk membaca tergantung pada tingkat keterampilan rekan programmer Anda. Selain itu, ini memindahkan fungsionalitas dari situs panggilan. Yang bisa membuat perawatan sedikit lebih sulit.

Saya tidak yakin apakah tujuan Anda adalah memasukkan kunci ke vektor atau mencetaknya ke cout, jadi saya melakukan keduanya. Anda dapat mencoba sesuatu seperti ini:

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

Atau bahkan lebih sederhana, jika Anda menggunakan 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";
}

Secara pribadi, saya suka versi BOOST_FOREACH karena mengetik kurang dan sangat eksplisit tentang apa yang dilakukannya.

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

Ada adaptor jangkauan jelajah untuk tujuan ini:

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

Ada adaptor rentang map_values ​​serupa untuk mengekstraksi nilai.

C ++ 0x telah memberi kami solusi lebih lanjut, sangat baik:

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

@ Jawaban DanDan, menggunakan C ++ 11 adalah:

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

dan menggunakan C ++ 14 (seperti dicatat oleh @ ivan.ukr) kita dapat mengganti decltype(map_in)::value_typedengan auto.

SGI STL memiliki ekstensi yang disebut select1st. Sayang sekali tidak dalam STL standar!

Solusi Anda baik-baik saja tetapi Anda dapat menggunakan iterator untuk melakukannya:

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
}

Berbasis pada solusi @ rusty-taman, tetapi dalam c ++ 17:

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

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

Saya pikir BOOST_FOREACH yang disajikan di atas bagus dan bersih, namun, ada opsi lain menggunakan BOOST juga.

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

Secara pribadi, saya tidak berpikir pendekatan ini sebersih pendekatan BOOST_FOREACH dalam kasus ini, tetapi boost :: lambda dapat benar-benar bersih dalam kasus lain.

Juga, jika Anda memiliki Peningkatan, gunakan transform_iterator untuk menghindari membuat salinan kunci sementara.

Sedikit dari c ++ 11 take:

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

Anda dapat menggunakan boost serbaguna :: transform_iterator. Transform_iterator memungkinkan Anda untuk mengubah nilai yang diulang, misalnya dalam kasus kami ketika Anda ingin hanya berurusan dengan kunci, bukan nilai. Lihat http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Inilah templat fungsi yang bagus menggunakan C ++ 11 magic, yang bekerja untuk 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;
}

Lihat di sini: http://ideone.com/lYBzpL

Solusi STL non-sgi, non-boost terbaik adalah memperluas peta :: iterator seperti:

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

dan kemudian gunakan seperti itu:

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

Dengan contoh peta atom

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

Sedikit mirip dengan salah satu contoh di sini, disederhanakan dari std::mapperspektif penggunaan.

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

Gunakan seperti ini:

auto keys = getKeys(yourMap);

(Saya selalu bertanya-tanya mengapa std :: map tidak menyertakan fungsi anggota untuk kita lakukan.)

Karena itu tidak bisa melakukannya lebih baik daripada Anda bisa melakukannya. Jika implementasi metode tidak akan lebih unggul daripada implementasi fungsi bebas maka secara umum Anda tidak boleh menulis metode; Anda harus menulis fungsi gratis.

Juga tidak jelas mengapa itu berguna.