C++ の std::map に相当する Java Map keySet() はありますか?

StackOverflow https://stackoverflow.com/questions/2467000

  •  20-09-2019
  •  | 
  •  

質問

C++ の Java Map keySet() に相当するものはありますか std::map?

ジャワ keySet() メソッドの戻り値 「このマップに含まれるキーのセット ビュー。」

役に立ちましたか？

解決 3

おそらく次のものが役立つかもしれません。

#include <iostream>
#include <iterator>
#include <algorithm>
#include <map>
#include <set>
#include <string>

template< class Key, 
          class T, 
          class Comparator,
          class MapAllocator,
          class SetAllocator>
void make_key_set(const std::map<Key,T,Comparator,MapAllocator>& map, 
                  std::set<Key,Comparator,SetAllocator>& set)
{
   set.clear();
   typedef typename std::map<Key,T,Comparator,MapAllocator> map_type;
   typename map_type::const_iterator itr = map.begin();
   while (map.end() != itr)
   {
      set.insert((itr++)->first);
   }
}

int main()
{
  std::map<std::string, double> m;

  m["one"] = 1.1;
  m["two"] = 2.2;
  m["three"] = 3.3;

  std::set<std::string> key_set;

  make_key_set(m,key_set); 

  std::copy(key_set.begin(), key_set.end(),
            std::ostream_iterator<std::string>(std::cout, "\n"));

  return  0;
}

の過負荷 メイクキーセット std::vector、std::deque、std::list などの STL 互換シーケンスを取る関数は次のようになります。

template< class Key, 
          class T, 
          class Comparator,
          class MapAllocator,
          class SeqAllocator,
          template<class,class> class Sequence>
void make_key_set(const std::map<Key,T,Comparator,MapAllocator>& map, 
                  Sequence<Key,SeqAllocator>& sequence)
{
   sequence.clear();
   typedef typename std::map<Key,T,Comparator,MapAllocator> map_type;
   typename map_type::const_iterator itr = map.begin();
   while (map.end() != itr)
   {
      sequence.push_back((itr++)->first);
   }
}

他のヒント

理想的ではないかもしれない、これまでに提示し、直接std::setを作成結局答え、のすべて：あなたはキーのみを反復することができるようにしたい場合は、新しい全体を作成するオーバーヘッドを持っている必要はありませんコンテナます。

より柔軟なオプションは、逆参照するときだけキーを生成するイテレータのいくつかのタイプにstd::mapイテレータを変換変換イテレータを使用することです。この変換をブーストを使用してイテレータかなり簡単です。

#include <functional>
#include <boost/iterator/transform_iterator.hpp>

// You may already have a select1st implementation; if not, you should :-)
template <typename Pair>
struct select1st
    : std::unary_function<const Pair&, const typename Pair::first_type&>
{
    const typename Pair::first_type& operator()(const Pair& p) const 
    { 
        return p.first; 
    }
};

template <typename C>
boost::transform_iterator<
    select1st<typename C::value_type>, typename C::const_iterator
> begin_keys(const C& c) 
{ 
    return boost::make_transform_iterator(
        c.begin(), select1st<typename C::value_type>()
    );
}

template <typename C>
boost::transform_iterator<
    select1st<typename C::value_type>, typename C::const_iterator
> end_keys(const C& c) 
{ 
    return boost::make_transform_iterator(
        c.end(), select1st<typename C::value_type>()
    );
}

これらのユーティリティ関数を使用すると、あなただけのキーの範囲に（あなたが持つかもしれない他のペアの連想コンテナにまたはイテレータ）std::mapイテレータの任意の範囲を変換することができます。例として：

#include <iostream>
#include <iterator>
#include <map>

int main()
{
    std::map<int, int> m;
    m.insert(std::make_pair(1, 2));
    m.insert(std::make_pair(2, 4));
    m.insert(std::make_pair(3, 6));

    std::copy(
        begin_keys(m), end_keys(m), 
        std::ostream_iterator<int>(std::cout, ","));
}

このプログラムの出力：

1,2,3,

あなたが本当にキーを含むstd::setを希望した場合は、あなたが簡単にこれらのイテレータを使用して作成することができます：

std::set<int> s(begin_keys(m), end_keys(m));

全体的に、それはより柔軟なソリューションです。

あなたはブーストを持っていないか、ブーストを使用しないか、ブーストを使用することができない場合は、この特定のイテレータは非常に簡単に実装できる変換ます：

#include <iterator>

template <typename C>
class key_iterator
    : public std::iterator<
          std::bidirectional_iterator_tag, 
          typename C::key_type, 
          typename C::difference_type, 
          typename C::pointer, 
          typename C::reference
      >
{
public:

    key_iterator() { }
    explicit key_iterator(typename C::const_iterator it) : it_(it) { }

    typename const C::key_type& operator*() const  { return  it_->first; }
    typename const C::key_type* operator->() const { return &it_->first; }

    key_iterator& operator++() { ++it_; return *this; }
    key_iterator operator++(int) { key_iterator it(*this); ++*this; return it; }

    key_iterator& operator--() { --it_; return *this; }
    key_iterator operator--(int) { key_iterator it(*this); --*this; return it; }

    friend bool operator==(const key_iterator& lhs, const key_iterator& rhs)
    {
        return lhs.it_ == rhs.it_;
    }

    friend bool operator!=(const key_iterator& lhs, const key_iterator& rhs)
    {
        return !(lhs == rhs);
    }

private:

    typename C::const_iterator it_;
};

template <typename C>
key_iterator<C> begin_keys(const C& c) { return key_iterator<C>(c.begin()); }

template <typename C>
key_iterator<C> end_keys(const C& c)   { return key_iterator<C>(c.end());   }

これの使用は、ブーストバージョンと同じである。

ここワンアンド・ビットライナーである

map<K,V> m;
...
// Useful stuff goes here
...
set<K> s;
transform(m.begin(), m.end(), inserter(s, s.begin()), select1st<pair<K,V> >());

あなたはselect1stを持っていない場合：

template <class P>
struct select1st : public std::unary_function<P, typename P::first_type>
{
    const typename P::first_type& operator()(const P &arg) const { return arg.first; }
};

あなたはそれを自分で実装することができます：

vector<T> keys;
for (map<T,S>::iterator it=m.begin(); it!=m.end; it++)
  keys.push_back(it->first)

Boost.Range を提供このようブースト::アダプタ:: map_valuesするます：

std::map my_map;
for (auto &value : my_map | boost::adaptors::map_values) {
    //...
}
ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top