在C+中实现Java集合层次结构+； #包括 使用名称空间std； 模板类迭代器 { T*ptr； 公众： 迭代器（T*addr） { ptr=NULL； ptr=addr； } //不起作用 //虚拟迭代器*运算符++（int x）； /*迭代器*运算符++（int x） { （本->ptr）+； 归还这个； }*/ T算子*（） { 返回*ptr； } }; 模板 类向量{ T*a； 公众： 向量（大小\u t n） { a=新的T[5]； } T&运算符[]（int x） { 返回a[x]； } 类迭代器：公共迭代器 { 公众： 迭代器（T*addr）：迭代器（addr） {} /*不起作用 迭代器*运算符++（int x） { 迭代器：：ptr++； 归还这个； }*/ //现在工作 迭代器*运算符++（int x） { 迭代器：：ptr++； 归还这个； } }; 迭代器begin（） { 迭代器ob（&a[0]）； 返回ob； } }; int main（） { 向量v（5）； for（int i=0；i

虚拟函数只能通过指针来调用。您的

begin

函数不会返回指针。如果您解决了这个问题，那么您将获得大量与类型转换相关的编译错误

您也可以使用引用，但它应该是r值引用：

Vector <char>:: iterator p=v.begin();

Iterator&&p=v.begin（）；

以下是具有正确后缀增量版本的示例实现：

Iterator<char> &&p = v.begin();

模板
类迭代器
{
私人：
T*ptr；
公众：
迭代器（T*ptr1）：ptr（ptr1）
{
}
虚拟迭代器运算符++（int）
{
迭代器结果（*this）；
（本->ptr）+；
返回结果；
}
T算子*（）
{
返回*ptr；
}
};
模板
类向量
{
私人：
T*数据；
公众：
向量（）
{
数据=新T（100）；
对于（int i=0；i您的代码几乎可以正常工作。我只需修复其中的3个问题：


如果您希望能够在派生类的重写方法中访问它，则应在
Iterator
类中保护
ptr
而不是私有
递增运算符应该声明为
虚拟迭代器…
如果要将数组迭代到null值，则应在末尾写入null值

因此，它在没有警告的情况下编译，并在Clang 3.4.1中运行良好：

template<typename T> 

class Iterator
{
    private: 
    T* ptr;
    public:
    Iterator(T* ptr1):ptr(ptr1)
    {
    }
    virtual Iterator  operator ++(int)
    {
        Iterator result(*this);
        (this->ptr)++;
        return result;
    }
    T operator*()
    {
        return *ptr;
    }
};

template<typename T>
class Vector
{
    private:
    T* data;
    public:
    Vector()
    {
        data = new T(100);
        for(int i=0;i<100;i++)
         data[i]=i;
    }


Iterator<T> begin()
{
    return Iterator<T>(&(data[0]));
}
};

#包括
使用名称空间std；
模板类迭代器
{
受保护的：
T*ptr；
公众：
迭代器（T*addr）
{
ptr=NULL；
ptr=addr；
}
//不工作-事实上工作完美
虚拟迭代器*运算符++（int x）
{
（本->ptr）+；
归还这个；
}
T算子*（）
{
返回*ptr；
}
};
模板
类向量{
T*a；
公众：
向量（大小\u t n）
{
a=新的T[5]；
}
T&运算符[]（int x）
{
返回a[x]；
}
类迭代器：公共迭代器
{
公众：
迭代器（T*addr）：迭代器（addr）
{}
/*不起作用
迭代器*运算符++（int x）
{
迭代器：：ptr++；
归还这个；
}*/
//现在正在工作，但是没有用，因为我们可以使用基类版本
/*迭代器*运算符++（int x）
{
迭代器：：ptr++；
归还这个；
}*/
};
迭代器begin（）
{
迭代器ob（&a[0]）；
返回ob；
}
};
int main（）
{
向量v（5）；
对于（inti=0；i让我先说一句，您的实现将不会像您预期的那样工作。当前看到的所有其他答案也不会

使用指针作为多态迭代器的实现注定会失败，polymorhphsm不会改变这样一个事实，即必须实现所有多态的具体迭代器

类似java（我假设有一些熟悉），一个全局多态性<代码> Iterator <代码>是有可能的，现在C++没有专用接口，我们有纯的虚拟类。
#include <iostream>
using namespace std;

template <typename T> class Iterator
{
protected:
T * ptr;

public: 

    Iterator(T * addr)
    {
        ptr=NULL;
        ptr=addr;
    }

    //not working - in fact works perfectly
    virtual Iterator<T> * operator ++(int x)
    {
        (this->ptr)++;
        return this;
    }

    T operator *()
    {
        return *ptr;
    }
};

template<typename T>
class Vector{

T * a;
public:
    Vector(size_t n)
    {
        a=new T[5];
    }
    T& operator [](int x)
    {
        return a[x];
    }
    class iterator: public Iterator<T>
    {
        public:

            iterator(T * addr): Iterator<T>(addr)
            {}

            /* not working 
            Iterator<T> * operator ++(int x)
            {
                Iterator<T>::ptr++;
                return this;
            }*/


            //working now but useless as we can use the base class version
            /*iterator * operator ++(int x)
            {
                Iterator<T>::ptr++;
                return this;
            }*/
    };
    iterator begin()
    {
        iterator ob(&a[0]);
        return ob;
    }
};

int main()
{

Vector <char> v(5);

for(int i=0;i<5;i++)
    v[i]=i+65;

for(int i=0;i<5;i++)
    cout<<v[i]<<endl;

v[5] = 0;  // set a null at the end of the vector

/*~~~~~~ What I want~~~~~~ and that works...*/

Iterator <char> p=v.begin();    



// what is working now:

//Vector<char>:: iterator p=v.begin();

while(*p){
    cout<<*p<<endl;
    p++;
   }

   return 0;
}

模板
类迭代器
{
公众：
虚拟迭代器和运算符++（）=0；//纯虚拟
//其他方法
};
模板
类向量
{
类迭代器//向量的具体迭代器
：public:：Iterator//类似于Java中的实现
{
公众：
迭代器和运算符++（）重写{/*实现*/}
//其他方法。。。
};
};
模板
班级名单
{
类迭代器//列表的具体迭代器
：public：：迭代器//实现
{
公众：
迭代器和运算符++（）重写{/*实现*/}
//其他方法。。。
};
};

因为多态仅适用于引用和指针，C++中的引用需要明确地写

template<typename T>
class Iterator
{
public:
    virtual Iterator& operator++() = 0; // pure virtual
    // other methods
};

template<typename T>
class Vector
{
    class Iterator  // Vector's concrete Iterator
      : public ::Iterator<T>  // analogous to implements in Java
    {
    public:
        Iterator& operator++() override { /* implementation */ }
        // other methods...
    };
};

template<typename T>
class List
{
    class Iterator  // List's concrete Iterator
      : public ::Iterator<T>  // implements
    {
    public:
        Iterator& operator++() override { /* implementation */ }
        // other methods...
    };
};

向量v；
清单l；
迭代器&rit=v.begin（）；
常量迭代器&crit=l.begin（）；

是如何使用迭代器的

多态性是一种工具，滥用它比不拥有它更糟糕。要考虑性能损失，并权衡它提供的灵活性。< /P>为什么要在迭代器上运行时多态性？实际使用什么？在java中，我们有一个迭代器接口，但是C++中，我们使用vector：：迭代器和A。另一个用于列表等。所以我想做的是创建一个迭代器基类。然后使用基类引用调用不同的迭代器实现，例如，列表的实现与向量的实现不同。因此在运行时，它会根据“迭代器”的对象确定要调用哪个迭代器实现参考是指。你没有回答我。我已经知道你想要运行时多态性。我问的是为什么。就像实际的用例一样。我想知道你的用例有多特别，因为基于概念，c
#include <iostream>
using namespace std;

template <typename T> class Iterator
{
protected:
T * ptr;

public: 

    Iterator(T * addr)
    {
        ptr=NULL;
        ptr=addr;
    }

    //not working - in fact works perfectly
    virtual Iterator<T> * operator ++(int x)
    {
        (this->ptr)++;
        return this;
    }

    T operator *()
    {
        return *ptr;
    }
};

template<typename T>
class Vector{

T * a;
public:
    Vector(size_t n)
    {
        a=new T[5];
    }
    T& operator [](int x)
    {
        return a[x];
    }
    class iterator: public Iterator<T>
    {
        public:

            iterator(T * addr): Iterator<T>(addr)
            {}

            /* not working 
            Iterator<T> * operator ++(int x)
            {
                Iterator<T>::ptr++;
                return this;
            }*/


            //working now but useless as we can use the base class version
            /*iterator * operator ++(int x)
            {
                Iterator<T>::ptr++;
                return this;
            }*/
    };
    iterator begin()
    {
        iterator ob(&a[0]);
        return ob;
    }
};

int main()
{

Vector <char> v(5);

for(int i=0;i<5;i++)
    v[i]=i+65;

for(int i=0;i<5;i++)
    cout<<v[i]<<endl;

v[5] = 0;  // set a null at the end of the vector

/*~~~~~~ What I want~~~~~~ and that works...*/

Iterator <char> p=v.begin();    



// what is working now:

//Vector<char>:: iterator p=v.begin();

while(*p){
    cout<<*p<<endl;
    p++;
   }

   return 0;
}

template<typename T>
class Iterator
{
public:
    virtual Iterator& operator++() = 0; // pure virtual
    // other methods
};

template<typename T>
class Vector
{
    class Iterator  // Vector's concrete Iterator
      : public ::Iterator<T>  // analogous to implements in Java
    {
    public:
        Iterator& operator++() override { /* implementation */ }
        // other methods...
    };
};

template<typename T>
class List
{
    class Iterator  // List's concrete Iterator
      : public ::Iterator<T>  // implements
    {
    public:
        Iterator& operator++() override { /* implementation */ }
        // other methods...
    };
};

Vector<int> v;
List<int> l;
Iterator<int>&& rit = v.begin();
const Iterator<int>& crit = l.begin();