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

我正在做一个作业，教授要求链表的迭代器必须是一个单独的头文件

然而，我所看到的迭代器的所有实现都在bag/list类中定义了类。所以我不知道如何在bag-like中创建迭代器

dlist<int>::iterator it1

dlist:：迭代器it1

没有在列表中定义它

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

dnode.h

模板
类dnode{
公众：
dnode（）{
linknext=NULL；
prevlink=NULL；
}
void set_data（T item）{data_value=item；}
void set_next（dnode*link）{linknext=link；}
无效集_prev（dnode*link）{prevlink=link；}
T data（）常量{return data_value；}
dnode*next（）{return linknext；}
dnode*prev（）{return prevlink；}
私人：
dnode*linknext；
dnode*prevlink；
T数据_值；
};

dlist.h

#包括“dnode.h”
#包括“iterator.h”
模板
类列表{
公众：
dlist（）{head=tail=NULL；}
无效后U插入（T数据）；
无效前端插入（T数据）；
无效前_移除（）；
空后_拆卸（）；
void reverse_show（）；
void show（）；
迭代器begin（）{返回迭代器（头）；}
迭代器end（）{return iterator（tail）；}
迭代器r_begin（）{返回迭代器（tail）；}
迭代器r_end（）{返回迭代器（头）；}
在（迭代器和当前项，T项）之后插入\u{
dnode*tmp；
tmp=新的dnode；
当前.get_dnode（）->next（）->set_prev（tmp）；
tmp->set_数据（项目）；
tmp->set_next（current.get_dnode（）->next（））；
tmp->set_prev（current.get_dnode（））；
当前.get_dnode（）->set_next（tmp）；
}
无效插入\u之前（迭代器和当前，T项）{
dnode*tmp；
tmp=新的dnode；
当前.get_dnode（）->prev（）->set_next（tmp）；
tmp->set_数据（项目）；
tmp->set_next（current.get_dnode（））；
tmp->set_prev（current.get_dnode（）->prev（））；
当前.get_dnode（）->set_prev（tmp）；
}
友元类迭代器；
私人：
dnode*头；
dnode*尾；
};

迭代器

模板
类迭代器
{
公众：
迭代器（dnode*first=NULL）{current=first；}
dnode*get_dnode（）{返回当前；}
运算符*（）常量{return current->data（）；}
迭代器和运算符++（）{
当前=当前->下一步（）；
归还*这个；
}
迭代器和运算符++（int）{
迭代器原件（当前）；
当前=当前->下一步（）；
归还原件；
}
迭代器和运算符--（）{
当前=当前->上一页（）；
归还*这个；
}
迭代器和运算符--（int）{
迭代器原件（当前）；
当前=当前->上一页（）；
归还原件；
}
布尔运算符==（常量迭代器某物）常量{return current==something.current；}
布尔运算符！=（常量迭代器某物）常量{return current==something.current；}
私人：
dnode*电流；
};

感谢您的帮助。

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

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;


}

模板
班级名单{
公众：
类迭代器；
结构节点；
节点*头；
迭代器begin（）
{
回流头；
}
迭代器结束（）
{
返回头->上一步；
}
};
模板
类列表：：迭代器{
节点*pos；
公众：
迭代器（node*p）：pos（p）{}
// ...
};
模板
结构列表：：节点{
节点*下一步；
节点*prev；
// ...
};
void f（）
{
清单l；
列表：：迭代器i=l.begin（）；
列表：：节点n；
}

在list、node或迭代器的定义中，您应该不再需要list:：前缀。在外部（包括在这些类之外定义的函数上的返回类型），您确实需要list:：prefix

---

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

您应该研究友元方法/类，比如在iterator类中包含友元类list？关闭。为了减少耦合，让迭代器类成为List类的朋友，然后在List类中创建一个方法，返回迭代器在itdlist上进行迭代。cpp是打字错误，不是吗？应该是dlist.h吗？如果没有，您可能会在将来的某个时候使用链接器遇到一些麻烦。另一件事是，它们是单独编译的头文件，因此如果没有编译器因为我使用了一个它不知道存在的类而生气，我就不能使用dlist:：iterator

#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;

};

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;


}