自定义迭代器类中重载的`！=`运算符无法正常工作

Question

I am creating template matrix class and right now I am implementing iterator class to iterate through one column (this iterator class is inside my Matrix<T> class).

template <typename P, typename V> // "P" - PointerType; "V" - ValueType
class V_Iterator : public std::iterator<std::forward_iterator_tag, T> {
private:
    P itData_;
public:
    size_type w; // width of the matrix
    size_type h; // height of the matrix
public:
    V_Iterator(P d) : itData_(d) { }

public:
    V& operator*() const {
        return *itData_;
    }
    /////////////////// BUG /////////
    V_Iterator<P, V>& operator++() {

        itData_ += w;

        return *this;
    }
    V_Iterator<P, V>& operator= (T value) {
        *itData_ = value;
        return *this;
    }
    P operator->() {
        return itData_;
    }
    friend bool operator==(const V_Iterator& lhs, const V_Iterator& rhs) {
        return !(lhs.itData_ != rhs.itData_);
    }
    friend bool operator!=(const V_Iterator& lhs, const V_Iterator& rhs) {
        return !(lhs.itData_ == rhs.itData_);
    }

    V_Iterator<P, V> begin(size_type column) { return V_Iterator<P, V>(itData_ + column); }
    V_Iterator<P, V> end(size_type column) { return V_Iterator<P, V>((itData_ + column) + 1 + (h - 1) * w ); };
};

My problem is that when I am iterating using my iterator:

Matrix<int> m (5, 5);
for (Matrix<int>::viterator vit = m.v_begin(0); vit != m.v_end(0); ++vit) {
    cout << *vit << " ";
}

it never stops because != is never triggered. However if in overloading ++ operator is this code instead of one I already posted

V_Iterator<P, V>& operator++() {
    ++itData_;
    return *this;
}

It is working completely fine.

Here is more code inside my Matrix class:

public:
V_Iterator<T*, T> m_viterator_;
V_Iterator<const T*, const T> m_const_viterator_;

typedef V_Iterator<T*, T> viterator;
typedef V_Iterator<const T*, const T> const_viterator;

viterator v_begin(size_type column) { return m_viterator_.begin(column); }
viterator v_end(size_type column) { return m_viterator_.end(column); }
const_viterator cv_begin(size_type column) { return m_const_hiterator_.begin(column); }
const_viterator cv_end(size_type column) { return m_const_hiterator_.end(column); }

Matrix class constructor:

Matrix(const size_type& width, const size_type& height) :   width_(width),
                                                            height_(height),
                                                            data_(CreateMatrix(width, height)),                                                                m_viterator_(*data_),
                                                            m_const_viterator_(*data_) {

    m_viterator_.w = width_;
    m_viterator_.h = height_;
    m_const_viterator_.w = width_;
    m_const_viterator_.h = height_;

    // fill the created matrix with default values of "T"
    for (Matrix<T>::iterator_type it = this->begin(); it != this->end(); ++it)
        *it = T();
}

I was trying to figure out what is wrong but to me everything seems ok.

Answer 1

As it's being pointed out in the comments, it's not shown how the w member gets initialized. However, I also spotted something else. I'm going to assume that the rest of the code that's not shown is going to initialize w correctly. Let's look at how you defined begin() and end().

V_Iterator<P, V> begin(size_type column)
{
     return V_Iterator<P, V>(itData_ + column);
}

V_Iterator<P, V> end(size_type column)
{
     return V_Iterator<P, V>((itData_ + column) + 1 + (h - 1) * w);
}

So, it looks to me like the distance between begin(n) end end(n) or end(n)-begin(n) is:

(itData_ + column) + 1 + (h - 1) * w - (itData_ + column)

or

1 + (h - 1) * w

You have stated the problem as follows: when your ++ operator keeps advancing the iterator by w each time, the loop iterating from begin to end will never compare equal to the ending iterator value.

Of course not, because the distance between them will never be an even multiple of w !

Answer 2

The iterator returned by the begin() and end() member functions does not have w and h initialised. You set them in the m_viterator member, but the member functions begin() and end() of the iterator class return an iterator initialised from the itData_ member only, which leaves w and h in the newly created iterator uninitialised.