迭代器作为 C++ 中链表类之外的单独类

Iterator as a separate class outside of the class of a linked list in C++

本文关键字：单独类 链表 C++ 迭代器      更新时间：2023-10-16

我正在尝试完成一项作业，其中教授要求链表的迭代器必须是单独的头文件。

但是，我见过的所有迭代器的实现都具有bag/list类内部类的定义。所以我不知道如何在袋子内创建一个迭代器，比如 

dlist<int>::iterator it1

无需在列表中定义它。

作为参考，以下是我的列表、节点和迭代器类：

dnode.h

template <class T>
class dnode{
    public:
        dnode(){
            linknext = NULL;
            prevlink = NULL;
        }
        void set_data(T item){data_value = item;}
        void set_next(dnode<T> *link){linknext = link;}
        void set_prev(dnode<T> *link){prevlink = link;}
        T data()const{return data_value;}
        dnode *next(){return linknext;}
        dnode *prev(){return prevlink;}
    private:
        dnode *linknext;
        dnode *prevlink;
        T data_value;
};

dlist.h

#include "dnode.h"
#include "iterator.h"
template <class T>
class dlist{
    public:
        dlist(){head = tail = NULL;}
        void rear_insert(T data);
        void front_insert(T data);
        void front_remove();
        void rear_remove();
        void reverse_show();
        void show();
        iterator<T> begin(){return iterator<T>(head);}
        iterator<T> end(){return iterator<T>(tail);}
        iterator<T> r_begin(){return iterator<T>(tail);}
        iterator<T> r_end(){return iterator<T>(head);}
        void insert_after(iterator<T>& current,T item){
            dnode<T>* tmp;
            tmp = new dnode<T>;
            current.get_dnode()->next()->set_prev(tmp);
            tmp->set_data(item);
            tmp->set_next(current.get_dnode()->next());
            tmp->set_prev(current.get_dnode());
            current.get_dnode()->set_next(tmp);
        }
        void insert_before(iterator<T>& current,T item){
            dnode<T>* tmp;
            tmp = new dnode<T>;
            current.get_dnode()->prev()->set_next(tmp);
             tmp->set_data(item);
            tmp->set_next(current.get_dnode());
            tmp->set_prev(current.get_dnode()->prev());
            current.get_dnode()->set_prev(tmp);

        }
              friend class iterator<T>;
    private:
        dnode<T> *head;
        dnode<T> *tail;
};

迭代器.h

template <class T>
    class iterator
{
    public:    
        iterator(dnode<T> *first = NULL){current = first;}
    dnode<T>* get_dnode(){return current;}
    T& operator *()const{return current->data();}
    iterator& operator ++(){
        current = current->next();
        return *this;
    }
    iterator& operator ++(int){
        iterator original(current);
        current = current->next();
        return original;
    }
    iterator& operator --(){
        current = current->prev();
        return *this;
    }
    iterator& operator --(int){
        iterator original(current);
        current = current->prev();
        return original;
    }
    bool operator ==(const iterator something)const{ return current == something.current;}
    bool operator !=(const iterator something)const{ return current == something.current;}


private:
    dnode<T> *current;

};

感谢您的任何帮助。

您可以在列表类中声明迭代器和节点类型，但在其他地方定义它们。您需要的语法形式如下：

template <class T>
class list {
public:
    class iterator;
    struct node;
    node* head;
    iterator begin()
    {
        return head;
    }
    iterator end()
    {
        return head->prev;
    }
};
template <class T>
class list<T>::iterator {
    node* pos;
public:
    iterator(node* p) : pos (p) { }
    // ...
};
template <class T>
struct list<T>::node {
    node* next;
    node* prev;
    // ...
};
void f()
{
    list<int> l;
    list<int>::iterator i = l.begin();
    list<int>::node n;

}

在列表、节点或迭代器的定义中，您不再需要 list：： 前缀。在外部（包括在这些类外部定义的函数的返回类型），您确实需要 list：： 前缀。

在这种形式中，您的包含结构将与上面的结构相反，其中 list.h 不需要包含 node.h 或 iterator.h，但这两个文件都将包含 list.h。您可能希望在 list.h 的末尾包含 node.h 和 iterator.h，以便类的用户可以通过包含 list.h 来获取所有定义。

相关文章：