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

Question

我正在创建模板矩阵类，现在我正在实现迭代器类来迭代一列（这个迭代器类在我的Matrix<T> 类中）。

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

我的问题是当我使用迭代器进行迭代时：

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

它永远不会停止，因为!= 永远不会被触发。但是，如果在重载 ++ 运算符时是此代码而不是我已经发布的代码

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

它工作得很好。

这是我的 Matrix 类中的更多代码：

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类构造函数：

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();
}

我试图找出问题所在，但对我来说一切正常。

Answer 1

begin() 和 end() 成员函数返回的迭代器没有初始化 w 和 h。您将它们设置在 m_viterator 成员中，但迭代器类的成员函数 begin() 和 end() 返回一个仅从 itData_ 成员初始化的迭代器，从而将 w 和 h 留在新创建的迭代器未初始化。

Answer 2

正如 cmets 中所指出的，它没有显示 w 成员是如何初始化的。不过，我也发现了别的东西。我将假设其余未显示的代码将正确初始化w。让我们看看你是如何定义 begin() 和 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);
}

所以，在我看来 begin(n) end end(n) 或 end(n)-begin(n) 之间的距离是：

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

或

1 + (h - 1) * w

您已将问题陈述如下：当您的 ++ 运算符每次都将迭代器向前推进 w 时，从 begin 迭代到 end 的循环将永远不会与结束迭代器值进行比较。

当然不是，因为它们之间的距离永远不会是w的偶数倍！