Re: for_each() and two-dimensional array
On 27 Maj, 08:13, John Harrison <john_androni...@hotmail.com> wrote:
Eric Lilja wrote:
On 26 Maj, 23:43, John Harrison <john_androni...@hotmail.com> wrote:
Does it look better? One thing that worries me is if I should be more
"helpful" if the user calls operator++() on an iterator that is
already at the end?
- Eric
Yes, looks better.
It's really your call whether to include error checking. You'll likely
save yourself some debugging headaches if you do, and in this case it's
a pretty simple check to make. Throw an exception if you detect an
error, because although it's easy to detect errors, it's not clear how
to handle them in this code.
If you do include error checking then not only operator++ on an iterator
that has reached the end, but also operator* on an iterator at the end.
john
Thanks for your valuable input (again), John! I will include error
checking
in operator++ and operator* then. Maybe inside an #ifdef DEBUG block.
However, right now I'm struggling to get my iterator working if my
MatrixBase
object is const. Maybe you could elaborate a bit more what I need to
do?
Do I need to create a new iterator class similar to const_iterator
found
in many stl containers?
Yes, and very tedious it is too.
Iterator and const_iterator have much in common. For instance their data
members will be the same, operator== will be the same for both, although
operator++ is different (different return type) the technique for
incrementing both kinds of iterator is the same, etc. etc. So two
techniques tend to be used. Either derive iterator and const_iterator
from a common base, or derive iterator from const_iterator. Don't forget
that you can assign an iterator to a const_iterator but not the other
way around. If you take the second of my suggestions you get this
behaviour automatically, otherise your const_iterator class will need a
constructor that takes an iterator.
I tried creating const versions of begin(), end() and operator*() but
either
I did it wrong or it's not enough, because I get errors. I don't have
the
code available right now but I will post it if I can't get it working.
No you need two classes and two sets of methods. Const begin() returns
const_iterator, operator* is always const because it doesn't change the
iterator itself, (this is not what I told you earlier).
- Eric
john
Hi John! Based on your input I've made the following changes. The
MatrixBase no longer makes the assumption that it's being instantiated
with a pointer type. As you said, there's no reason of doing that. I
also made a Iterator class with two child classes, MatrixIterator and
ConstMatrixIterator and I've changed MatrixBase::begin()/end() to
reflect that. Here's my code and it seems to work. I can iteratate
over a const MatrixBase object using the ConstMatrixIterator and I can
use MatrixIterator if I have non-const object and want to change what
the iterator points to. The code posted below compiles with three
different compilers. I haven't figured out how to handle assignment of
iterators you mentioned or if I can put the boolean operators in the
base class. Comments? I have all the functionality I need now, but if
there are some simple changes I could make to make it better, I'd love
to hear them. :) I'm putting this to work in my implementation of the
game of life, one of my current projects. :) This part of the project
has taken a lot more work than I expected, but I've learnt alot!
The code:
#ifndef MATRIXBASE_H
#define MATRIXBASE_H
#include <cassert>
template<typename T>
class MatrixBase
{
public:
MatrixBase(int num_rows, int num_columns)
: num_rows_(num_rows), num_columns_(num_columns) {}
virtual ~MatrixBase()
{
for (int y = 0; y < num_rows_; ++y)
{
for (int x = 0; x < num_columns_; ++x)
{
delete tiles_[y][x];
}
delete[] tiles_[y];
}
delete[] tiles_;
}
/* Also handle the rule of three... */
virtual void allocate()
{
assert(num_rows_ > 0 && num_columns_ > 0);
tiles_ = new T*[num_rows_];
for (int y = 0; y < num_rows_; ++y)
{
tiles_[y] = new T[num_columns_];
}
}
class Iterator
{
protected:
Iterator(const MatrixBase *matrix = 0, int row = -1, int column
= -1)
: matrix_(matrix), row_(row), column_(column) {}
public:
Iterator& operator++()
{
if (row_ == matrix_->num_rows_ - 1 && column_ == matrix_-
num_columns_ - 1)
{
/* Now when row_ == matrix_->num_rows_ and column_ ==
matrix_->num_columns_
* that means we are at the end. */
++row_;
++column_;
}
else if (column_ == matrix_->num_columns_ - 1)
{
++row_;
column_ = 0;
}
else
{
++column_;
}
/* Maybe add special case for if operator++() is called on an
* end() iterator? */
return *this;
}
protected:
T& dereference()
{
if (row_ < 0 || row_ >= matrix_->num_rows_ ||
column_ < 0 || column_ > matrix_->num_columns_)
throw; // FIXME
return matrix_->tiles_[column_][row_];
}
const MatrixBase *matrix_;
int row_;
int column_;
};
class MatrixIterator : public Iterator
{
public:
MatrixIterator() : Iterator(0, -1, -1) {}
friend class MatrixBase;
T& operator*()
{
return Iterator::dereference();
}
/* MSVC++ wants a typename here or it will issue a warning. */
bool operator!=(const typename MatrixBase::MatrixIterator& rhs)
const
{
return
Iterator::matrix_ != rhs.matrix_ || Iterator::row_ !=
rhs.row_ ||
Iterator::column_ != rhs.column_;
}
/* MSVC++ wants a typename here or it will issue a warning. */
bool operator==(const typename MatrixBase::MatrixIterator& rhs)
const
{
return !(*this != rhs);
}
private:
MatrixIterator(MatrixBase *matrix, int row = 0, int column = 0)
: Iterator(matrix, row, column) {}
};
class ConstMatrixIterator : public Iterator
{
public:
ConstMatrixIterator() : Iterator(0, -1, -1) {}
friend class MatrixBase;
const T& operator*()
{
return Iterator::dereference();
}
/* MSVC++ wants a typename here or it will issue a warning. */
bool operator!=(const typename MatrixBase::ConstMatrixIterator&
rhs) const
{
return
Iterator::matrix_ != rhs.matrix_ || Iterator::row_ !=
rhs.row_ ||
Iterator::column_ != rhs.column_;
}
/* MSVC++ wants a typename here or it will issue a warning. */
bool operator==(const typename MatrixBase::ConstMatrixIterator&
rhs) const
{
return !(*this != rhs);
}
private:
ConstMatrixIterator(const MatrixBase *matrix, int row = 0, int
column = 0)
: Iterator(matrix, row, column) {}
};
MatrixIterator begin()
{
return MatrixIterator(this);
}
ConstMatrixIterator begin() const
{
return ConstMatrixIterator(this);
}
MatrixIterator end()
{
return MatrixIterator(this, num_rows_, num_columns_);
}
ConstMatrixIterator end() const
{
return ConstMatrixIterator(this, num_rows_, num_columns_);
}
protected:
T **tiles_;
int num_rows_;
int num_columns_;
};
#endif
- Eric