为什么来自覆盖类的指针使用运算符==和基类中的运算符！=

我有用于类和类的迭代器模板，用于 for 语句。

template<class T>
class Itr2 {
public:
     Itr2()  { }
    ~Itr2()  { }
    typedef typename Itr2 type;
    typedef typename T& reference;
    virtual type& operator++()                      { return *this; }
    virtual T&    operator*()                       { return ((reference)*((type*)this)); }
    virtual bool  operator==(const type& o) const { return true; }
    virtual bool  operator!=(const type& o) const { return false; }
};

template<class T>
class I2
{
public:
    typedef I2<T> type;
    typedef T     value;
    typedef T& reference;
    typedef typename Itr2<T> iterator;
    virtual iterator& begin() { return *(new iterator()); }
    virtual iterator& end()   { return *(new iterator()); }
};

接下来，我为标准 std：：vector<> 创建了类。

template<class T>
class ItrSTD : public Itr2<T> {
public:
    typedef typename Itr2<T> base_type;
    typedef typename ItrSTD<T> type;
    typedef typename T& reference;
    typedef typename std::vector<T>::iterator std_itr;
protected:
    std_itr itr_;
public:
    ItrSTD(const type& o)                               { itr_ = o.itr_; }
    ItrSTD(const std_itr& o)                            { itr_ = o; }
    virtual base_type&  operator++()                    { itr_++; return *this; }
    virtual T&          operator*()                     { return ((reference)(*this->itr_)); }
    bool  operator==(const base_type& o) const override { return (((const type&)o).itr_ == this->itr_); }
    bool  operator!=(const base_type& o) const override { return (((const type&)o).itr_ != this->itr_); }
};

template<class T>
class VSTD : public I2<T> {
protected:
    std::vector<T>  arr_;
public:
    typedef typename ItrSTD<T>  iterator;
    VSTD(const VSTD& o)  { arr_ = o.arr_; }
    template<typename ...E> VSTD(E&&...e) : arr_({ std::forward<T>(e)... }) {  }
    iterator& begin()  _NOEXCEPT  override{ return (*new iterator(arr_.begin())); }
    iterator& end()    _NOEXCEPT  override{ return (*new iterator(arr_.end())); }
};

如果我使用 Direct 语句 for（int i：v）。 它工作正常，但是当我尝试从指针编译器执行此操作时，请使用基类运算符！=（而不是覆盖运算符！=）并且代码无法:(工作。

int v_i = 0;
VSTD<int> vstd_a = { 1, 2, 3 };
I2<int> *i2 = &vstd_a;
for (int j : *i2) //DOESN't work :( use operator!= from base class
{
v_i += j;
}
for (int j : vstd_a) //work fine :)  use operator!= from VSTD.
{
 v_i += j;
}

如果我简化代码：

template<typename T>
class I3
{
public:
    T i;
    virtual bool  operator==(const I3& o) const { return false; }
};
template<typename T>
class I3O : public I3<T>
{
public:
    virtual bool  operator==(const I3& o) const override { return true; }
};
I3O<int> i3_a, i3_b; I3<int> *i3_ap, *i3_bp;
i3_ap = &i3_a; i3_bp = &i3_b; bool i3_c;
i3_c = (i3_a == i3_b);
i3_c = ((*i3_ap) == (*i3_bp));

两个结果都很好（返回 true）并从覆盖类进行比较（仅适用于（ ： ） 工作不好:(：

为什么会这样。是否可以将 for 语句用于模板指针？begin（）， end（） 函数工作正常。只有操作员的工作方式不同。

附言我使用VS2013编译器。