Conversion between custom iterator and custom constant iterator - c++

Question

I am working on generic two-dimensional container with custom iterators.
Now I am trying to have one begin() and one end() function for both my iterator and constant_iterator type.
My custom iterator is inside my template Matrix class (but I put them here separately for the sake of the clarity).
template <class T>
class Matrix {
#pragma mark PUBLIC TYPEDEFS
public:
typedef T value_type;
typedef std::size_t size_type;
//typedef typename T::size_type size_type;
//typedef T::size_type size_type;
#pragma mark -
#pragma mark PRIVATE TYPEDEFS
private:
typedef T* pointer_type;
typedef T** storage_type;
#pragma mark -
#pragma mark PRIVATE VARIABLES
private:
size_type width_;
size_type height_;
storage_type data_;
// private iterators
Iterator<T*, T> m_iterator_;
Iterator<const T*, const T> m_const_iterator_;
H_Iterator<T*, T> m_hiterator_;
H_Iterator<const T*, const T> m_const_hiterator_;
#pragma mark -
#pragma mark PUBLIC VARIABLES & TYPEDEFS
public:
typedef Iterator<T*, T> iterator_type;
typedef Iterator<const T*, const T> const_iterator_type;
typedef H_Iterator<T*, T> hiterator;
typedef H_Iterator<const T*, const T> const_hiterator;
#pragma mark -
#pragma mark CONSTRUCTORS & DESTRUCTORS
public:
explicit Matrix(const std::string& fileName) {
}
Matrix(const size_type& width, const size_type& height) : width_(width),
height_(height),
data_(CreateMatrix(width, height)),
m_iterator_(*data_, width, height),
m_const_iterator_(*data_, width, height),
m_hiterator_(*data_, width, height),
m_const_hiterator_(*data_, width, height),
// fill the created matrix with default values of "T"
for (Matrix<T>::iterator_type it = this->begin(); it != this->end(); ++it)
*it = T();
}
~Matrix() {
delete [] data_[0]; // because in data_[0] is array of value_type
delete [] data_;
}
#pragma mark -
#pragma mark PRIVATE METHODS
private:
storage_type CreateMatrix(const size_type width, const size_type height) {
storage_type d = new pointer_type[height]; // array with pointers pointing to rows inside the "block"
pointer_type block = new value_type[width * height]; // one block of memory to store the data
for (size_type row = 0; row < height; ++row)
d[row] = &block[row * width];
return d;
}
#pragma mark -
#pragma mark PUBLIC METHODS
public:
hiterator h_begin(size_type row) { return m_hiterator_.begin(row); }
hiterator h_end(size_type row) { return m_hiterator_.end(row); }
const_hiterator ch_begin(size_type row) { return m_const_hiterator_.begin(row); }
const_hiterator ch_end(size_type row) { return m_const_hiterator_.end(row); }
And my inner Iterator class + derived H_Iterator class (H_Iterator class is for looping through one row of matrix from left to right)
#pragma mark ITERATOR CLASSES
template <typename P, typename V> // "P" - PointerType; "V" - ValueType
class Iterator : public std::iterator<std::forward_iterator_tag, T> {
protected:
P itData_;
size_type w_; // width of the matrix
size_type h_; // height of the matrix
public:
Iterator(P d, size_type width, size_type height) : itData_(d), w_(width), h_(height) { }
Iterator() { }
public:
V& operator*() const {
return *itData_;
}
Iterator<P, V>& operator++() {
++itData_;
return *this;
}
Iterator<P, V>& operator= (T value) {
*itData_ = value;
return *this;
}
P operator->() {
return itData_;
}
friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
return !(lhs.itData_ != rhs.itData_);
}
friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
return !(lhs.itData_ == rhs.itData_);
}
Iterator<P, V> begin() { return Iterator<P, V>(itData_, w_, h_); }
Iterator<P, V> end() { return Iterator<P, V>(itData_ + w_ * h_, w_, h_); };
};
template <typename P, typename V> // "P" - PointerType; "V" - ValueType
class H_Iterator : public Iterator<P, V> {
public:
H_Iterator(P d, size_type width, size_type height) : Iterator<P, V>(d, width, height) { }
H_Iterator() { }
public:
H_Iterator<P, V> begin(size_type row) { return H_Iterator<P, V>(this->itData_ + this->w_ * row, this->w_, this->h_); }
H_Iterator<P, V> end(size_type row) { return H_Iterator<P, V>(this->itData_ + this->w_ * row + this->w_, this->w_, this->h_); };
};
Currently if I want to loop through one of the rows using constant iterator I must do it like this (=I must use begin and end function that was made specifically for constant_hiterator - ch_begin() and ch_end()):
Matrix<int> m (5, 5);
for (Matrix<int>::const_hiterator hit = m.ch_begin(row); hit != m.ch_end(row); ++hit) {
cout << *hit << " ";
}
I am struggling to have only one begin() and end() function for both my const_hiterator and hiterator. So I can write iterators code similarly like iterators for std::vector:
std::vector<int> vector;
for (std::vector<int>::const_iterator it = vector.begin(); it != vector.end(); ++it) { }
for (std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it) { }
I assume that I should have some type of conversion between hiterator and const_hiterator.

Answer 1

There are some heavy head-winds that throw a few monkey wrenches here. Actually, it is common for custom containers to have separate begin() and end() iterators for mutable and constant iterators for one very simple reason, best demonstrated by the following example. This example demonstrates the typical container/iterator semantics that the C++ library implements, and is generally desired for custom container/iterators to implement the same way:
class CustomContainer {
public:
class const_iterator {
// ...
};
class iterator : public const_iterator {
// ...
};
iterator begin();
iterator end();
const_iterator begin() const;
const_iterator end() const;
};
The standard container/iterator semantics don't use separate begin() and end() methods for mutable and constant iterators. Rather, object.begin(), or pointer->begin() ends up invoking either the constant or the mutable version of begin() depending upon whether object or pointer is a reference/pointer to a mutable or a const instance of the class.
In summary:
1) A mutable iterator begin()/end() methods get called for mutable instances of the class.
2) A begin()/end() on a const instance of a class can only return the constant iterator type. If your begin()/end() operator would return mutable iterators when invoked on a const class instance, then this makes it possible to modify a const instance of the class by simply instantiating its mutable iterators!
3) It is strongly desired for a mutable iterator to be a subclass of the const iterator. This is the easiest way to automatically support passing a mutable iterator to a function or a method that only requires a const iterator parameter (it is also possible to implement that by defining and implementing an overload cast operator, but using subclasses is much easier, and typically results in better performance).
Now, certainly it would be convenient to have a single begin()/end() implementation. And it's not like there's legal requirement that mandates one to always properly support the typical iterator semantics.
But, correctly supporting these expected iterator semantics makes it much easier to leverage all the algorithms in the C++ library, and have them work correctly, with no surprises.
It is certainly possible to declare both mutable and constant begin() and end() methods as wrappers around a private factory that produces a mutable beginning or an ending iterator, with the constant begin()/end() facades degrading it to a constant iterator before returning it. That would be one possible approach. It's not ideal, since the private factory has to be a constant method, in order for it to be invokable from the constant begin()/end() wrappers.