C++11 映射值的迭代器（简单透明）

Question

我正在寻找一种简单的方法来为 C++11 中的 map 的值创建迭代器。

这个方法应该简单和透明：简单是因为它应该易于实现，透明是因为客户端不应该知道值来自映射，而不是集合。

这个问题已经被问过好几次了。其中许多问题早于 C++11 并使用了我不想使用的 boost。有些并不简单，John Ahlgren 的解决方案在这里，http://john-ahlgren.blogspot.com/2013/10/how-to-iterate-over-values-of-stdmap.html，例如需要一页代码来编写自定义迭代器。

其他的不是透明的，也就是说，很明显可以写：

map<string,foo> mymap;
for (auto it=mymap.begin();it!=mymap.end();++it){
  Foo val= it->second;
  ...
 }

但是，我不想这样做，因为我不希望客户端知道数据表示。

问题如下。

我有一堆用长“键”唯一索引的对象。有时我想操纵这些对象的集合。其他时候我想检索一个给定键的对象。

我不能直接使用“set”类有几个原因，其中主要是它不存储可变实例，并且这些实例必须是可变的（显然，除了键）。

所以，我决定将我所有的对象存储在一个巨大的全局哈希表中：

map<long,Foo> all_the_objects;

然后我根本不使用set<Foo>。相反，我使用 set<long> 并使用适配器来模拟一组 Foo，即，

class SetOfFoo{
  private: set<long> theKeys;
  public:
    void insert(const & Foo);
    size_t size() return theKeys.size();
    bool is_member(const & Foo)
      {return theKeys.find(Foo.key)
          != theKeys.end;}
    Foo & insert(const & Foo val){
       long key=val.key;
       all_the_objects[key]=val;
       return all_the_objects[key];
     }
    ...::iterator begin() {???}
}

换句话说，SetOfFoo 类的客户端不知道或不需要知道 SetOfFoo 是作为键集实现的。

我也不能自己在适配器类中创建一个 Vector，因为不能将引用存储在 C++ 集合中。

真的不可能用一种简单、透明的方式来迭代 map 值吗？我很难相信，因为这是一个非常普遍的需求，而且在我见过的每一种具有哈希表的语言中都是微不足道的。我只是不明白这有多难。

Answer 1

这很简单。

这是一个极其简单的版本，它最低限度地解决了整数到字符串的映射问题。您可以重写为您想要的类型，也可以根据需要对其进行模板化。

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

struct map_value_iterator : public std::map<int, std::string>::const_iterator
{
    map_value_iterator(std::map<int, std::string>::const_iterator src)
    : std::map<int, std::string>::const_iterator(std::move(src))
    {

    }

    // override the indirection operator
    const std::string& operator*() const {
        return std::map<int, std::string>::const_iterator::operator*().second;
    }
};


using namespace std;


int main()
{
    map<int, string> myMap { {1, "Hello" }, { 2, "World" } };

    copy(map_value_iterator(begin(myMap)), map_value_iterator(end(myMap)), ostream_iterator<string>(cout , " "));
    cout << endl;

    return 0;
}

程序输出：

Compiling the source code....
$g++ -std=c++11 main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1

Executing the program....
$demo 
Hello World 

Answer 2

您可以执行以下操作 (C++98)：

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

#include "util/pair_iterator.hpp"

template<class T> inline T const& constify(T& t) { return t; }

int main()
{
    using namespace std;
    using namespace util;

    map<int, string> m;
    m[0] = "alice";
    m[1] = "bob";
    m[2] = "carol";
    m[3] = "dave";
    m[4] = "eve";

    copy(
          over_second(m.begin())
        , over_second(m.end())
        , ostream_iterator<string>(cout, "\n")
        );

    copy(
          over_first(m.begin())
        , over_first(m.end())
        , ostream_iterator<int>(cout, "\n")
        );

    // const iterators check

    copy(
          over_second(constify(m).begin())
        , over_second(constify(m).end())
        , ostream_iterator<string>(cout, "\n")
        );

    copy(
          over_first(constify(m).begin())
        , over_first(constify(m).end())
        , ostream_iterator<int>(cout, "\n")
        );
}

这是一个实现：

// util/pair_iterator.hpp
#include <iterator>

#include "boost/iterator/transform_iterator.hpp"
#include "boost/type_traits/remove_reference.hpp"
#include "boost/type_traits/is_const.hpp"
#include "boost/mpl/if.hpp"

namespace util {

namespace aux {

template<class T> struct dereference_type
    : boost::remove_reference<typename std::iterator_traits<T>::reference>
{
};

template<class PairT>
struct first_extracter
{
    typedef typename boost::mpl::if_<
          boost::is_const<PairT>
        , typename PairT::first_type const
        , typename PairT::first_type
        >::type result_type;
    result_type& operator()(PairT& p) const { return p.first; }
};

template<class PairT>
struct second_extracter
{
    typedef typename boost::mpl::if_<
          boost::is_const<PairT>
        , typename PairT::second_type const
        , typename PairT::second_type
        >::type result_type;
    result_type& operator()(PairT& p) const { return p.second; }
};

} // namespace aux {

template<class IteratorT>
inline
boost::transform_iterator<aux::first_extracter<typename aux::dereference_type<IteratorT>::type>, IteratorT>
over_first(IteratorT const& i)
{
    typedef aux::first_extracter<typename aux::dereference_type<IteratorT>::type> extracter;
    return boost::transform_iterator<extracter, IteratorT>(i, extracter());
}

template<class IteratorT>
inline
boost::transform_iterator<aux::second_extracter<typename aux::dereference_type<IteratorT>::type>, IteratorT>
over_second(IteratorT const& i)
{
    typedef aux::second_extracter<typename aux::dereference_type<IteratorT>::type> extracter;
    return boost::transform_iterator<extracter, IteratorT>(i, extracter());
}

} // namespace util