固定大小的多索引多态容器提升多索引

Question

仍然深入研究C++/boost，以便欢迎任何意见/反馈。

我在玩boost :: unordered_maps，并创建了一个使用形状的多态示例，关于我头脑 缠绕（大部分）的时间，我偶然发现了boost multi_index的mru示例。 http://www.boost.org/doc/libs/1_46_1/libs/multi_index/example/serialization.cpp

那时我想。嗯，一个固定大小的多索引多态容器，将丢弃基于 LRU的值，这听起来很疯狂而不实现。

#include <boost/multi_index_container.hpp> 
    #include <boost/multi_index/hashed_index.hpp> 
    #include <boost/multi_index/identity.hpp> 
    #include <boost/multi_index/sequenced_index.hpp> 
    #include <boost/shared_ptr.hpp> 
    #include <boost/tuple/tuple.hpp> 
    #include "boost/tuple/tuple_comparison.hpp" 

    enum shape_returns { 
     SHAPE_ERROR = -1, 
     SHAPE_OK = 0 
    }; 

    // coordinates 
    typedef boost::tuples::tuple<int, int, int> ShapeKey; 

    class Shape { 
    public: 
     Shape() : pos() {} 
     ~Shape() {} 

     virtual int draw() { return SHAPE_ERROR; } 

     ShapeKey pos; 
    }; 
    typedef boost::shared_ptr<Shape> Shape_ptr; 

    class Circle : public Shape { 
    public: 
     Circle() {} 
     ~Circle() {} 

     int radius; 

     virtual int draw() { /* draw stuff */ return SHAPE_OK; } 
    }; 
    typedef boost::shared_ptr<Circle> Circle_ptr; 

    class Square : public Shape { 
    public: 
     Square() {} 
     ~Square() {} 

     int len; 

     virtual int draw() { /* draw stuff */ return SHAPE_OK; } 
    }; 
    typedef boost::shared_ptr<Square> Square_ptr; 

    using namespace boost::multi_index; 

    // multi index tags 
    struct seq {}; 
    struct hash {}; 

    class ShapesLRU { 
     typedef boost::multi_index::multi_index_container< 
      Shape_ptr, 
      boost::multi_index::indexed_by< 
      boost::multi_index::sequenced<boost::multi_index::tag<seq> >, 
      boost::multi_index::hashed_unique< 
       boost::multi_index::tag<hash>, 
       boost::multi_index::identity<Shape_ptr> 
      > 
      > 
     > shapes_list; 

    public: 
     typedef typename shapes_list::iterator iterator; 
     typedef typename boost::multi_index::index<shapes_list, seq>::type seq_index; 
     typedef typename boost::multi_index::index<shapes_list, hash>::type hashed_index; 

     ShapesLRU (std::size_t max) : max_shapes(max) {} 
     ~ShapesLRU() {} 

     void insert(const Shape_ptr item) 
     { 
      std::pair<typename shapes_list::iterator, bool> ret = shapes.push_front(item); 

      if (!ret.second) { 
       // new item may be different 
       erase(item->pos); 
       ret = shapes.push_front(item); 
      } else if (shapes.size() > max_shapes) { 
       shapes.pop_back(); 
      } 
     } 

     typename shapes_list::iterator begin() { return shapes.begin(); } 
     typename shapes_list::iterator end() { return shapes.end(); } 

     typename hashed_index::iterator hash_begin() { return shapes.get<hash>().begin(); } 
     typename hashed_index::iterator hash_end() { return shapes.get<hash>().end(); } 

     typename hashed_index::iterator find(const ShapeKey &key) 
     { 
      Shape_ptr tmp(new Shape()); 
      tmp->pos = key; 

      // XXX why compiler error w/o "using namespace boost::multi_index" 
      return shapes.get<hash>().find(tmp); 
     } 

     void erase(const ShapeKey &key) 
     { 
      typename hashed_index::iterator itr = find(key); 
      // XXX why compiler error w/o "using namespace boost::multi_index" 
      shapes.get<hash>().erase(itr); 
     } 

    private: 
     // The multi-indexed data store 
     shapes_list shapes; 

     // The size of the data store 
     std::size_t max_shapes; 
    }; 

    inline std::size_t 
    hash_value(const Shape_ptr shape) 
    { 
     std::size_t seed = 0; 

     boost::hash_combine(seed, shape->pos.get<0>()); 
     boost::hash_combine(seed, shape->pos.get<1>()); 
     boost::hash_combine(seed, shape->pos.get<2>()); 

     return seed; 
    } 

    int 
    main() 
    { 
     ShapesLRU shapes(10); 

     Circle_ptr cptr1(new Circle()); 
     ShapeKey pos1(1, 1, 1); 
     cptr1->pos = pos1; 
     cptr1->radius = 1; 

     Circle_ptr cptr2(new Circle()); 
     ShapeKey pos2(2, 2, 2); 
     cptr2->radius = 2; 
     cptr2->pos = pos2; 

     shapes.insert(cptr1); 

     ShapesLRU::hashed_index::iterator itr = shapes.find(pos1); 

     return 0; 
    } 

经过大量的工作后，我仍然留下以下问题。

1. 在插入

   （）是有办法从序列 迭代得到hashed_unique迭代器，所以我可以直接调用抹去？

2. 有没有更好的方法实现查找？如果我只用键就可以找到类似 的boost :: unordered_map，而不必为查找创建一个虚拟的 形状。

3. 获得<>的正确途径是什么（请参阅代码XXX中的评论）我尝试了一切，我是正确的，然后开始尝试随机废话，没有任何摆脱。

4. 我真的想一[]操作，但我认为这是长的路...... 形状[cptr1-> POS] = cptr1;

5. 如何从我的hash_index :: iterator中获得项目（或通常意义上的这个项目），打印它当然没有帮助...

p ITR $ 1 = {，性病::分配器>>>，升压:: multi_index ::详细:: bucket_array>>>，升压:: shared_ptr的，长，提高:: shared_ptr的常量*， boost :: shared_ptr const & >> = {，std :: allocator>>>，boost :: multi_index :: detail :: bucket_array>>>，boost :: shared_ptr const *，boost :: iterator，long，boost :: shared_ptr的常量*，升压:: shared_ptr的常量&> >> = {，性病::分配器>>>，升压:: multi_index ::详细:: bucket_array>>>，升压:: shared_ptr的常量*，升压：迭代， long，boost :: shared_ptr const *，boost :: shared_ptr const &> >> = {，std :: allocator>>>，boost :: multi_index :: detail :: bucket_array>>>，boost :: incrementable，std： ：allocator> >>，boost :: multi_index :: det ail :: bucket_array>>，boost :: dereferenceable，std :: allocator>>>，boost :: multi_index :: detail :: bucket_array>>，boost :: shared_ptr const *，boost :: iterator，long，boost :: shared_ptr的常量*，升压:: shared_ptr的常量&>>> >> = {，性病::分配器>>>，升压:: multi_index ::详细:: bucket_array>>>，升压::提领，性病::分配器>>>，提振:: multi_index ::详细:: bucket_array>>>，提高:: shared_ptr的常量*，提振::迭代器，长，提高:: shared_ptr的常量*，提高:: shared_ptr的常量&>> >> = {，std :: allocator>>>，boost :: multi_index :: detail :: bucket_array>>>，boost :: shared_ptr const *，boost :: iterator，long，boost :: shared_ptr const *，boost :: shared_ptr常量&> >> = {，长，提高:: shared_ptr的常量*，提高:: shared_ptr的常量& >> = {，长，提高:: shared_ptr的常量*，提高:: shared_ptr的常量& >> = {，长，提高:: shared_p TR常量*，升压:: shared_ptr的常量& >> = {}，}，}，}，}，}，}，}，}，节点= 0x60a010，水桶= 0x7fffffffdd88}

Answer 1

在插入件（）有没有办法从 序列迭代器中获得hashed_unique迭代器，所以我可以直接调用erase？

请参阅iterator projection。

有没有更好的办法工具找到？这很好，如果我可以用找到像boost :: unordered_map那样的密钥，而不是让 为查找创建一个虚拟形状。

首先，我认为你目前的实现是错误的：你的散列索引是基于Shape_ptr平等，后 - 您希望根据Shape::ShapeKey平等这是不是你的东西。为了得到这一点，只需重新定义索引

boost::multi_index::hashed_unique< 
    boost::multi_index::tag<hash>, 
    boost::multi_index::member<Shape,ShapeKey,&Shape::pos> 
> 

对于这个工作，你必须实现的哈希为ShapeKey，留给:-)现在实施find演习是

hashed_index::iterator find(const ShapeKey &key) 
{ 
    return shapes.get<hash>().find(key); 
} 

一样简单

是什么让<>（参见代码XXX评论）我试过 一切，我是正确的，然后就开始尝试随机废话， 从来都没有摇出正确的路径。

我不明白为什么你的语法是行不通的。这应该。

我真的很喜欢[]运算符，但我认为这是一种方式... ... shapes [cptr1-> pos] = cptr1;

指数Boost.MultiIndex中被std::set和std::unordered_set，而不是std::map和std::unordered_map模仿（为根本原因，我们不必在这里讨论。）但是，认为这是一个map<T,Q>是一个很值得set<mutable_pair<T,Q>>，其中mutable_pair是一对结构其第二位成员是mutable。你可以利用这个等价性来构建带有Boost.MultiIndex的类地图结构。

怎样才能获得该项目（或使这个在一般意义上）从我hash_index：迭代，打印它肯定没有帮助...

你是什么意思“印刷“？