C++ 自己的迭代器不'；行不通

我自己的

迭代器

，应该可以迭代双链表。若我在迭代，那个么for循环将立即被跳过。我没有错误，但通过调试，我读得不多

对于

循环：

for(SemestralWork::DoubleList<Student>::iterator it = link->begin(); it != link->end(); ++it){
         //something...
    }

class iterator {
private:
    Node<T> * node;
public:
    iterator(){}
    iterator(const iterator& cit){}
    iterator(T t) {

    }
    ~iterator(){}

    iterator& operator=(const iterator& second){
        node = second.node;
        return(*this);
    }
    iterator& operator++(){     
        if (node != NULL){
            node = node->GetNext();
        }
        return(*this);
    }
    iterator operator++(int){
        iterator tmp = *this;   //iterator tmp(*this)
        operator++();
        return tmp;
    }
    bool operator==(const iterator& second) {
        return node == second.node;
    }
    bool operator!=(const iterator& second) {
        return node != second.node;
    }
    T& operator*() {return node->GetData();}
    T* operator->(){return((DoubleList<T>::iterator)*this);} 
};

iterator begin(){
    return iterator(first->GetData());
}

iterator end(){
    return iterator(last->GetData());
}

template <class U>
    class Node{
        Node<U> * next;
        Node<U> * previous;
        U data;
    public:
        Node(const U &data){
            next = NULL;
            previous = NULL;
            this->data = data;
        }
        void SetNext(Node<U> *next) { this->next = next; }
        Node<U> *GetNext(){ return next; }
        void SetPrevious(Node<U> *previous) { this->previous = previous; }
        Node<U> *GetPrevious(){ return previous; }
        U &GetData() { return data; }
    };

节点

：

for(SemestralWork::DoubleList<Student>::iterator it = link->begin(); it != link->end(); ++it){
         //something...
    }

class iterator {
private:
    Node<T> * node;
public:
    iterator(){}
    iterator(const iterator& cit){}
    iterator(T t) {

    }
    ~iterator(){}

    iterator& operator=(const iterator& second){
        node = second.node;
        return(*this);
    }
    iterator& operator++(){     
        if (node != NULL){
            node = node->GetNext();
        }
        return(*this);
    }
    iterator operator++(int){
        iterator tmp = *this;   //iterator tmp(*this)
        operator++();
        return tmp;
    }
    bool operator==(const iterator& second) {
        return node == second.node;
    }
    bool operator!=(const iterator& second) {
        return node != second.node;
    }
    T& operator*() {return node->GetData();}
    T* operator->(){return((DoubleList<T>::iterator)*this);} 
};

iterator begin(){
    return iterator(first->GetData());
}

iterator end(){
    return iterator(last->GetData());
}

template <class U>
    class Node{
        Node<U> * next;
        Node<U> * previous;
        U data;
    public:
        Node(const U &data){
            next = NULL;
            previous = NULL;
            this->data = data;
        }
        void SetNext(Node<U> *next) { this->next = next; }
        Node<U> *GetNext(){ return next; }
        void SetPrevious(Node<U> *previous) { this->previous = previous; }
        Node<U> *GetPrevious(){ return previous; }
        U &GetData() { return data; }
    };

模板
类节点{
节点*下一步；
节点*先前；
U数据；
公众：
节点（常数U和数据）{
next=NULL；
previous=NULL；
这->数据=数据；
}
void SetNext（Node*next）{this->next=next；}
Node*GetNext（）{return next；}
void SetPrevious（Node*previous）{this->previous=previous；}
Node*GetPrevious（）{return previous；}
U&GetData（）{return data；}
};

您没有发布显示

first

和

last

的列表实现，但我假设

last

指向最后一个元素。对于迭代器，

end（）

应该指向最后一个元素之外，而不是最后一个元素。例如，如果列表正好包含1个元素，那么For循环根本不会运行，因为

first==last

，因此

begin（）==end（）

您没有发布显示

first

和

last

的列表实现，但我假设

last

指向最后一个元素。对于迭代器，

end（）

应该指向最后一个元素之外，而不是最后一个元素。例如，如果列表正好包含1个元素，那么For循环将根本不会运行，因为

first==last

，因此

begin（）==end（）

我注意到了一些事情。我不知道这些是否能真正解决您的问题，因为发布的代码不完整：

您的

iterator

不应该从

T

对象构造，构造函数的实现应该实际做一些事情（我猜

iterator:：iterator（T）

根本不做任何事情的事实是您的实际问题）。相反，应该从

节点*

构造

迭代器

preincrement运算符不应检查是否存在下一个元素！迭代器可以递增是

运算符++（）

的先决条件。如果有任何问题，操作员应在启用调试设置的情况下报告误用

我怀疑您使用了

last

：请注意，结束迭代器的位置超过了最后一个元素

您的比较运算符应该是

const

成员，通常是

运算符=（）

只委托给

操作符==（）

，即：

bool iterator::operator!=(iterator const& other) const {
    return !(*this == other);
}

这个实现的优点是

操作符=（）

与

操作符==（）

一致，即使

操作符==（）

的实现发生了更改

---

以下是我注意到的一些事情。我不知道这些是否能真正解决您的问题，因为发布的代码不完整：

您的

iterator

不应该从

T

对象构造，构造函数的实现应该实际做一些事情（我猜

iterator:：iterator（T）

根本不做任何事情的事实是您的实际问题）。相反，应该从

节点*

构造

迭代器

preincrement运算符不应检查是否存在下一个元素！迭代器可以递增是

运算符++（）

的先决条件。如果有任何问题，操作员应在启用调试设置的情况下报告误用

我怀疑您使用了

last

：请注意，结束迭代器的位置超过了最后一个元素

您的比较运算符应该是

const

成员，通常是

运算符=（）

只委托给

操作符==（）

，即：

bool iterator::operator!=(iterator const& other) const {
    return !(*this == other);
}

这个实现的优点是

操作符=（）

与

操作符==（）

一致，即使

操作符==（）

的实现发生了更改

---

你有什么理由不使用std:：list吗？它已经是带有迭代器的双链表了。这是我学期的工作，我不能：（你有什么理由不使用std:：list吗？它已经是带有迭代器的双链表了。这是我学期的工作，我不能：（我明白了，好的。所以我必须使用例如

迭代器end（）{return（迭代器（NULL））；}

对吗？是的，只要指向最后一个元素的迭代器上的

++it

前进到

end（）

。取消引用

end（）

迭代器是错误的，所以你不必担心。我明白了，好的。所以我必须使用例如

迭代器end（）{return（迭代器（NULL））；}

对吗？是的，只要指向最后一个元素的迭代器上的

++it

前进到

end（）

。取消对

end（）

迭代器的引用是错误的，所以你不必担心。嗯，比我预期的更多问题：ad1：如果我创建下一个类似

迭代器的构造函数（Prvek*iter）：prvek（iter）{}

then

iterator begin（）

不知道这个构造函数，但是为什么呢？呃，比我预期的问题更多：D ad1：如果我创建下一个构造函数，比如

iterator（prvek*iter）：prvek（iter）{}

那么

iterator begin（）

不知道这个构造函数，但是为什么？