Làm cách nào để truy xuất tất cả các khóa (hoặc giá trị) từ std :: map và đặt chúng vào một vectơ?

Đây là một trong những cách có thể tôi đi ra:

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

Tất nhiên, chúng ta cũng có thể truy xuất tất cả các giá trị từ bản đồ bằng cách xác định một functor khác RetrieveValues .

Có cách nào khác để đạt được điều này một cách dễ dàng? (Tôi luôn tự hỏi tại sao std :: map không bao gồm chức năng thành viên để chúng tôi làm như vậy.)

Mặc dù giải pháp của bạn nên hoạt động, nó có thể khó đọc tùy thuộc vào mức độ kỹ năng của các lập trình viên đồng nghiệp của bạn. Ngoài ra, nó di chuyển chức năng ra khỏi trang web cuộc gọi. Mà có thể làm cho việc bảo trì khó khăn hơn một chút.

Tôi không chắc mục tiêu của bạn là đưa các phím vào một vectơ hay in chúng ra cout để tôi thực hiện cả hai. Bạn có thể thử một cái gì đó như thế này:

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

Hoặc thậm chí đơn giản hơn, nếu bạn đang sử dụng 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";
}

Cá nhân, tôi thích phiên bản BOOST_FOREACH vì ít gõ hơn và nó rất rõ ràng về những gì nó đang làm.

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

Có một bộ chuyển đổi phạm vi tăng cho mục đích này:

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

Có một bộ điều hợp phạm vi map_values ​​tương tự để trích xuất các giá trị.

C ++ 0x đã cho chúng ta một giải pháp tuyệt vời hơn nữa:

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

Câu trả lời của @ DanDan, sử dụng C ++ 11 là:

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

và sử dụng C ++ 14 (như được ghi chú bởi @ ivan.ukr) chúng ta có thể thay thế decltype(map_in)::value_typebằng auto.

SGI STL có một phần mở rộng được gọi là select1st. Quá tệ, nó không có trong STL tiêu chuẩn!

Giải pháp của bạn là tốt nhưng bạn có thể sử dụng một trình vòng lặp để làm điều đó:

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
}

Dựa trên giải pháp @ rusty-park, nhưng trong c ++ 17:

std :: map <int, int> mục;
std :: vector <int> itemKeys;

for (const auto & [key, bị bỏ qua]: mục)
{
    itemKeys.push_back (khóa);
}

Tôi nghĩ rằng BOOST_FOREACH được trình bày ở trên là tốt và sạch sẽ, tuy nhiên, có một tùy chọn khác sử dụng BOOST là tốt.

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

Cá nhân, tôi không nghĩ cách tiếp cận này sạch như cách tiếp cận BOOST_FOREACH trong trường hợp này, nhưng boost :: lambda có thể thực sự sạch trong các trường hợp khác.

Ngoài ra, nếu bạn có Boost, hãy sử dụng Transform_iterator để tránh tạo một bản sao tạm thời của các phím.

Bit của một c ++ 11 mất:

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

Bạn có thể sử dụng boost :: Transform_iterator đa năng. Transform_iterator cho phép bạn chuyển đổi các giá trị lặp, ví dụ trong trường hợp của chúng tôi khi bạn chỉ muốn xử lý các khóa, không phải các giá trị. Xem http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Đây là một mẫu hàm đẹp sử dụng phép thuật C ++ 11, hoạt động cho cả 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;
}

Kiểm tra nó ở đây: http://ideone.com/lYBzpL

Giải pháp STL không tăng tốc, không tăng tốc tốt nhất là mở rộng map :: iterator như vậy:

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

và sau đó sử dụng chúng như vậy:

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

Với ví dụ bản đồ nguyên tử

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

Hơi giống với một trong những ví dụ ở đây, được đơn giản hóa từ std::mapquan điểm sử dụng.

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

Sử dụng như thế này:

auto keys = getKeys(yourMap);

(Tôi luôn tự hỏi tại sao std :: map không bao gồm chức năng thành viên để chúng tôi làm như vậy.)

Bởi vì nó không thể làm điều đó tốt hơn bạn có thể làm. Nếu việc triển khai một phương thức sẽ không vượt trội so với triển khai chức năng miễn phí thì nói chung, bạn không nên viết một phương thức; bạn nên viết một hàm miễn phí

Nó cũng không ngay lập tức rõ ràng tại sao nó hữu ích.