Question

所以，我一直在试图弄清楚自定义迭代器是如何工作的，在投入了这么多时间后仍然很短，我决定向整个社区提问：我做错了什么？请帮助，解释会很好，但如果它是“次要的”则没有必要。

作为一个附带问题，有没有人知道要求“显示为收集协会”在MSVS中的类图事物中工作的要求是什么？它不适用于c ++吗？就我而言，即使我的bar2也不是一个整体的集合。

这是我的代码，它应该编译，但显然我的迭代器已经坏了......

编辑：由于人们在问，问题是我实现的迭代器不会迭代Bar

#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!=实际上是在测试是否相等。

我的自定义迭代器出了什么问题

1 个答案: