[Boost-users] [iterators] NULL pointer initialization and comparison using iterator_facade

From: Lang Stefan (SLang_at_[hidden])
Date: 2008-04-22 10:43:28

Hello list,

I have created a generic iterator template class for arrays that also
doubles as container-wrapper for the array in question. To achieve this
I have based my class on boost::iterator_facade . I have defined all the
neccessary functions as described in the documentation and mostly the
iterators work as intended.

Here's a cut-down version:

#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/iterator/iterator_facade.hpp>

template<class Value>
class cArrayIterator : public boost::iterator_facade<
          cArrayIterator<Value>
        , Value
        , boost::random_access_traversal_tag
      >
{
private:
    struct enabler {};
public:
        cArrayIterator()
            : first(0),size(0),position(0) {}
        cArrayIterator(Value* _first, difference_type _size,
difference_type _position = 0)
            : first(_first),size(_size),position(_position) {}
    template<class OtherValue>
        cArrayIterator(
        const cArrayIterator<OtherValue>& other
      , typename boost::enable_if<
            boost::is_convertible<OtherValue*,Value*>
          , enabler
        >::type = enabler()
    )
            :
first(other.first),size(other.size),position(other.position) {}
private:
        Value* first;
        difference_type position;
        difference_type size;

    friend class boost::iterator_core_access;
        void advance(difference_type n){

                position += n;
        }
        void decrement(){

                --position;
        }
        Value& dereference() const{

                return first[position];
        }
    template<class OtherValue>
        difference_type distance_to(const cArrayIterator<OtherValue>& z)
const{

                return z.position - this->position;
        }
    template<class OtherValue>
        bool equal(const cArrayIterator<OtherValue>& other) const{

                return this->first + this->position == other.first +
other.position;
        }
        void increment(){

                ++position;
        }

};

I have a big problem though: The project I am working on is quite big
and I intend to replace a particular typedef (currently simply a pointer
to a struct) with this iterator class. There are two kinds of
instructions though that my iterator class currently can't cope with:

1. Initializing a 'pointer' with NULL (in other words, I need a
constructor with one argument of type int, but only in case that
argument's value is 0)

2. Comparing a 'pointer' to NULL (again, comparison to int argument, but
only makes sense for the value 0)

I did add a constructor with only one argument (of type pointer to the
underlying object's type) and could eliminate problem 1. However I feel
it's not quite right, since for my array iterator it doesn't make any
sense to initialize it with just one pointer and no further information
(it requires pointer to first element, position, and size of array), so
in cases where the pointer argument is not NULL this constructor
shouldn't even be available!

Here's the code for the new constructor:

        cArrayIterator(Value* _first) // workaround
            : first(_first),position(0)
        {
        if (NULL == _first)
            size = 0;
        else
            size = 1; // not really sensible, but the best I can think
of atm
        }

Moreover, I hoped this constructor would also eliminate problem 2 by
implicitely converting the int value of 0 to a NULL iterator, but it
didn't. I tried to provide my own comparison operators, but so far
failed to meet the syntax the compiler would recognize as a fit for a
comparison int to iterator.

This is what I got so far:

template <class Value>
bool operator==(cArrayIterator<const Value> const left,
cArrayIterator<Value> const right)
{
    return false;// I'll take care of that once the function gets
actually called :/
}

How do I correctly define a comparison operator that compares a 'NULL
pointer' to a class representing a pointer? Or does iterator_facade
already provide a way to deal with this?

Stefan