我的自定義迭代器有什麼問題

Question

因此，我一直在試圖弄清楚自定義迭代器是如何工作的，在投入瞭如此多的時間並且仍然不足之後，我決定詢問整個社區：什麼是我做錯了？請幫忙，解釋會很好，但如果是「輕微」，則不需要。

作爲一個側面的問題，有沒有人知道什麼要求是「顯示爲集合關聯」在MSVS中的類圖事物中工作？它只是不適用於C++？就我們所知，即使我的bar2也不是一個整數。

這裏是我的代碼，它應該編譯，但顯然我的迭代器壞了...

編輯：既然人都在問，問題是，我實現了迭代器不遍歷酒吧

#include <vector> 
#include <iostream> 

using namespace std; 

template<class T> 
class Foo 
{ 
public: 
    template<class T> 

    class FooIterator : std::iterator<std::forward_iterator_tag, T, ptrdiff_t, T*, T&> 
    { 
    public: 
     Foo<T>* arrayPtr; 
     int index, size; 
     FooIterator(Foo<T>* arrayPtr, int size, int index) : arrayPtr(arrayPtr), size(size), index(index) {} 

     T& operator*() {return *(arrayPtr->operator[](index));} 
     T* operator->() {return &(operator*());} 

     FooIterator &operator++(){++index; return *this;} 
     FooIterator operator++(int){FooIterator tmp(*this); ++(*this); return tmp;} 
     bool operator!=(const FooIterator &other) const {return other.index == index;} 
    }; 

    T** ts; 
    int size; 
    int index; 

    typedef FooIterator<T> fooiterator; 
    fooiterator begin(){return fooiterator(this, size, 0);} 
    fooiterator end(){return fooiterator(this, size, size);} 

    ~Foo(); 

    void init(int size); 
    void insert(T* item); 
    T* operator[](int index); 

    typedef T   value_type; 
    typedef T*   pointer; 
    typedef const T* const_pointer; 
    typedef T&   reference; 
    typedef const T& const_reference; 
    typedef int  size_type; 
    typedef ptrdiff_t difference_type; 
}; 

template<class T> 
void Foo<T>::init(int size) 
{ 
    ts = new T*[size]; 
    index = 0; 
} 

template<class T> 
Foo<T>::~Foo() 
{ 
    for(int i = 0; i < index; i++) 
     delete ts[i]; 
    delete ts; 
} 

template<class T> 
void Foo<T>::insert(T* item) 
{ 
    ts[index++] = item; 
} 

template<class T> 
T* Foo<T>::operator[](int index) 
{ 
    return ts[index]; 
} 

struct Bar 
{ 
public: 
    Foo<int> nums; 
    Bar() 
    { 
     nums.init(3); 
     int val = 1; 
     nums.insert(new int(1)); 
     nums.insert(new int(2)); 
     nums.insert(new int(3)); 

     for each (int var in nums) 
     { 
      cout << var << endl; 
     } 
    } 
}; 

struct Bar2 
{ 
    vector<int> nums; 
    Bar2() 
    { 

     nums.push_back(4); 
     nums.push_back(5); 
     nums.push_back(6); 
     for each (int var in nums) 
     { 
      cout << var << endl; 
     } 
    } 
}; 

int main() 
{ 
    Bar bar; 
    /*for (int i = 0; i < bar.nums.index; i++) 
    { 
     cout << *bar.nums[i] << endl; 
    }*/ 
    Bar2 bar2; 
    cin.get(); 

    return 0; 
} 

Answer 1

一個顯而易見的問題是operator!=實際上測試是否相等。