Tüm anahtarları (veya değerleri) bir std :: haritasından nasıl alıp bir vektöre nasıl koyabilirim?

Bu, çıkmamın olası yollarından biri:

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

Tabii ki, başka bir işlev RetrieveValues tanımlayarak tüm değerleri haritadan da alabiliriz .

Bunu kolayca başarmanın başka bir yolu var mı? (Her zaman std :: map'in bizim için neden bir üye işlevi içermediğini merak ediyorum.)

Çözümünüz işe yarayacak olsa da, diğer programcılarınızın beceri seviyesine bağlı olarak okumak zor olabilir. Ayrıca, işlevselliği çağrı sitesinden uzaklaştırır. Bu da bakımı biraz daha zorlaştırabilir.

Amacınız anahtarları bir vektöre almak mı yoksa cout için onları yazdırmak mı olduğundan emin değilim. Böyle bir şey deneyebilirsiniz:

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

Veya daha da basit, Boost kullanıyorsanız:

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

Şahsen, daha az yazım olduğu ve ne yaptığı hakkında çok açık olduğu için BOOST_FOREACH sürümünü seviyorum.

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

Bu amaçla bir takviye aralığı adaptörü vardır :

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

Değerleri çıkarmak için benzer bir map_values ​​aralık bağdaştırıcısı vardır.

C ++ 0x bize başka, mükemmel bir çözüm sundu:

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

@ DanDan'ın cevabı, C ++ 11 kullanarak:

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

ve kullanırken (@ ivan.ukr tarafından belirtildiği gibi) ++ 14 biz yerine decltype(map_in)::value_typeile auto.

SGI STL adlı bir uzantı var select1st. Çok standart STL değil kötü!

Çözümünüz iyi ancak bunu yapmak için bir yineleyici kullanabilirsiniz:

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
}

@ Rusty parks çözümüne dayalı, ancak c ++ 17'de:

std :: map <int, int> öğeleri;
std :: vektör <int> itemKeys;

için (const auto & [anahtar, yoksayıldı]: öğeler)
{
    itemKeys.push_back (anahtar);
}

Yukarıda sunulan BOOST_FOREACH güzel ve temiz olduğunu düşünüyorum, ancak BOOST da kullanarak başka bir seçenek var.

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

Şahsen, bu yaklaşımın bu durumda BOOST_FOREACH yaklaşımı kadar temiz olduğunu düşünmüyorum, ancak boost :: lambda diğer durumlarda gerçekten temiz olabilir.

Ayrıca, Boost'unuz varsa, anahtarların geçici bir kopyasını yapmaktan kaçınmak için transform_iterator kullanın.

Bir c ++ 11'in biti:

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

Çok yönlü boost :: transform_iterator kullanabilirsiniz. Transform_iterator, yinelenen değerleri dönüştürmenize olanak tanır, örneğin bizim durumumuzda, değerleri değil yalnızca anahtarlarla uğraşmak istediğinizde. Bkz. Http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example

Her iki std :: map, std :: unordered_map için çalışan, C ++ 11 sihir kullanan güzel bir işlev şablonu:

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

Buradan kontrol edin: http://ideone.com/lYBzpL

En iyi sgi olmayan, desteklenmeyen STL çözümü haritayı genişletmektir: yineleyici şöyle:

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

ve sonra bunları şu şekilde kullanın:

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

Atomik harita örneği ile

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

Buradaki örneklerden birine biraz benzer, std::mapkullanım açısından basitleştirilmiştir .

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

Bunun gibi kullanın:

auto keys = getKeys(yourMap);

(Her zaman std :: map'in bizim için neden bir üye işlevi içermediğini merak ediyorum.)

Çünkü bunu yapabileceğinden daha iyi yapamaz. Bir yöntemin uygulanması bir serbest işlevin uygulamasından daha üstün olmayacaksa, genel olarak bir yöntem yazmamalısınız; ücretsiz bir işlev yazmalısınız.

Niçin faydalı olduğu hemen belli değil.