Mit boost::iterator

Schrieb ich eine sparse-Vektor-Klasse (siehe #1, #2.)

Möchte ich zwei Arten von Iteratoren:

Den ersten Satz, den regelmäßigen Iteratoren, können Punkt-jedes element, ob gesetzt oder nicht gesetzt. Wenn Sie Lesen, Sie kehren entweder der Sollwert oder value_type(), wenn Sie geschrieben werden, erstellen Sie das element und die Rückgabe der lvalue-Referenz. So sind Sie:

Random-Access-Traversal Iterator und Lesbar und Beschreibbar Iterator

Den zweiten Satz, das sparse-Iteratoren, Durchlaufen nur die set-Elemente. Da brauchen Sie nicht zu träge zu erstellen, die Elemente, die geschrieben werden, sind Sie:

Random-Access-Traversal Iterator und Lesbar und Beschreibbar und Lvalue Iterator

Brauche ich auch, const Versionen der beiden, die sind nicht beschreibbar.

Kann ich in die Leerstellen zu füllen, aber nicht sicher, wie die Verwendung von boost::iterator_adaptor zu beginnen.

Hier ist, was ich habe, so weit:

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

außerdem ist das illegal?

typedef boost::reverse_iterator<sparse_iterator> reverse_sparse_iterator;
InformationsquelleAutor Neil G | 2010-05-12
Schreibe einen Kommentar