使用提升::迭代

Question

我写了疏矢量级(见 #1, #2.)

我谨提供两种迭代:

第一组，定期的迭代，可以指任何元素、是否设置或取消。如果他们读到，他们返回设置价值或 value_type(), 如果他们是书面的，他们创建的元件和返回的左值的参考。因此，它们是：

随机存取历迭代 和 可读 和 可写的 迭代

第二组，稀疏的迭代，迭代过只有设元素。因为他们不需要懒洋洋地创造元素的书面要，它们是：

随机存取历迭代 和 可读 和 可写的 和 左值 迭代

我还需要const版本中的两个，这是不可写的。

我可以填补空白，但不能肯定如何使用升::iterator_adaptor开始。

这是我迄今为止:

template<typename T>
class sparse_vector {
public:
    typedef size_t size_type;
    typedef T value_type;

private:
    typedef T& true_reference;
    typedef const T* const_pointer;
    typedef sparse_vector<T> self_type;
    struct ElementType {
        ElementType(size_type i, T const& t): index(i), value(t) {}
        ElementType(size_type i, T&& t): index(i), value(t) {}
        ElementType(size_type i): index(i) {}
        ElementType(ElementType const&) = default;
        size_type index;
        value_type value;
    };
    typedef vector<ElementType> array_type;

public:
    typedef T* pointer;
    typedef T& reference;
    typedef const T& const_reference;

private:
    size_type                                   size_;
    mutable typename array_type::size_type      sorted_filled_; 
    mutable array_type                          data_;

// lots of code for various algorithms...

public:    
    class sparse_iterator
        : public boost::iterator_adaptor<
          sparse_iterator                   // Derived
          , typename array_type::iterator            // Base (the internal array)
          , value_type              // Value
          , boost::random_access_traversal_tag    // CategoryOrTraversal
          > {...}

    class iterator_proxy {
          ???
    };

    class iterator
        : public boost::iterator_facade<
          iterator                          // Derived
          , ?????                           // Base
          , ?????              // Value
          , boost::??????    // CategoryOrTraversal
          > {
    };
};

此外，这是违法的吗？

typedef boost::reverse_iterator<sparse_iterator> reverse_sparse_iterator;

Answer 1

我不确定你真的想要使用 iterator_adaptor 你的情况-你可能想要使用 iterator_facade 代替。

更彻底的解释： iterator_adaptors 是时使用现有一个迭代(让我们说 std::list<int>::iterator)，并要重复使用其行为对你的迭代。你迭代将返回值的两倍什么是在该列表中，但重用历代从原来的迭代器。或其他方式：你可能会想要一个迭代将跳过一些要素在原来的名单，但返回的价值不变。我不确定你是否想到你的迭代(如在重复使用代码)后的迭代的基础结构，但是说对于我，我不会特别是在非稀疏迭代为您可能想要创建一些代理为参照，这意味着你可以不使用任何基础的迭代 dereference() 代码，以及穿越可能是容易的。你可以，但是，基于你的 sparse_iterator 在一些迭代，迭代实际上现有的元件阵列，如果你想要的。

有问题的代理方法，所以不要指望它的工作完美地而不需要通过多的篮球。对于一件事情，const版本的非稀疏迭代仍然应该回 value_type(), ，这意味着表达喜欢 iter->foo() 应该翻译成 value_type().foo() 如果相应的条目并不存在。但这会造成困难， pointer_proxy::operator->() 应该返回的东西 operator->, ，最好指针(绝对不是 value_type()).这导致至关重要的问题：一个指向什么呢？有可能解决这个(一个，如果你有你的目管理 boost::shared_pointer, 你可以返回 shared_pointer 来一个 new'd的实例)。

为非稀疏迭代，需要实施：

• class reference_proxy 与
• reference_proxy::operator& (可能会返回一个指代理)
• reference_proxy::operator value_type&() 为const使用
• reference_proxy::operator const value_type&() 对于非常量使用

• reference_proxy::foo() 对于任何 foo() 部件的功能value_type(无表情喜欢 (*it).foo() 据我所知不会的工作)

• class pointer_proxy 与

• pointer_proxy::operator* (返回reference_proxy)
• pointer_proxy::operator-> (做的一些明智的，参见上文)

的参数，以迭代立面模板应该是：

• Reference:的 reference_proxy
• Pointer:的 pointer_proxy

疏版本是简单的：如果基础的迭代是合理的(即。相匹配的行为你想要的)和正确地实现，你就可以省略的参数 iterator_adaptor (除了一两个)，并采取所有执行。

将"不编纂"的问题：插入 typename.