双链表迭代器实现的问题

Problems with Doubly-Linked List iterator implementation

本文关键字：问题 实现 迭代器 链表      更新时间：2023-10-16

我在使用一个简单的双链接列表类时遇到了一些问题。

这是我所有的代码：

/*
 * DLList.h
 *
 *  Created on: Nov 19, 2013
 *      Author: tyler
 */
#ifndef DLLIST_H_
#define DLLIST_H_
#include <iostream>
using namespace std;
template <typename T>
class DLList{
private:
struct DLLNode{
private:
    T data_;
    bool visited_;
    DLLNode* next_;
    DLLNode* prev_;
public:
    DLLNode(T data){
        this->data_ = data;
        visited_ = false;
        next_ = NULL;
        prev_ = NULL;
    }
    void setData(T data){
        this->data_ = data;
    }
    void visit(){
        visited_ = true;
    }
    void unvisit(){
        visited_ = false;
    }
    void setNext(DLLNode* next){
        this->next_ = next;
    }
    void setPrev(DLLNode* prev){
        this->prev_ = prev;
    }
    T& getData(){
        return data_;
    }
    bool getVisited(){
        return visited_;
    }
    DLLNode* getNext(){
        return next_;
    }
    DLLNode* getPrev(){
        return prev_;
    }
};
    DLLNode* head_;
    DLLNode* tail_;
public:
    DLList(){
        head_ = NULL;
        tail_ = NULL;
    }
    class DLLiterator{
    private:
        DLLNode* node;
    public:
        DLLiterator(){
            node = head_;
        }
        T& operator*(const DLLiterator& iter){
            return iter.node->getData();
        }
        DLLiterator& operator++(const DLLiterator& iter){
            if(node->getNext() != NULL)
                node = node->getNext;
            else
                node = NULL;
            return *this;
        }
    };   
    bool isEmpty(){
        return (head_ == NULL);
    }
    void addNodeEnd(T data){
        DLLNode* temp = new DLLNode(data);
        if(isEmpty()){
            head_ = temp;
            tail_ = temp;
        }
        else{
            DLLNode* curr;
            curr = tail_;
            curr->setNext(temp);
            temp->setPrev(curr);
            tail_ = temp;
        }
    } 
    bool contains(T data){
        for(DLLNode* start = head_; start != NULL; start = start->getNext()){
            if(start->getData() == data)
                return true;
        }
        return false;
    }
    void remove(T data){
        for(DLLNode* curr = head_; curr != NULL; curr = curr->getNext()){
            DLLNode* key = curr;
            if(curr->getData() == data){
                if(curr == head_){
                    head_ = key->getNext();
                    key->getNext()->setPrev(NULL);
                    delete key;
                }
                if(curr == tail_){
                    tail_ = key->getPrev();
                    key->getPrev()->setNext(NULL);
                    delete key;
                }
                else{
                    DLLNode* prev;
                DLLNode* next;
                    prev = key->getPrev();
                    next = key->getNext();
                    prev->setNext(next);
                    next->setPrev(prev);
                    delete key;
                }
            }
        }
    }
    void printList(){
        for(DLLNode* curr = head_; curr != NULL; curr = curr->getNext()){
            cout << curr->getData() << "n";
        }
    }
};

#endif /* DLLIST_H_ */

我的问题是，我不知道如何在外部类中实际使用迭代器。其他一切都经过了测试，似乎运行良好。仍然需要添加一个简单的析构函数，但我现在的重点是迭代器。任何帮助都会很棒。

我试着做：

DLLiterator iter;

但这显然是错误的。。。

编辑：这是操作员++代码：

iterator operator++(){
    if(node_->getNext() != NULL)
        node_ = node_->getNext;
    else
        node_ = NULL;
    return *this;
}

但现在它要求一个int作为论据。。。？

在类之外，您必须使用限定名称DLList<whatever>::DLLiterator。您可以看到，在嵌套名称中添加疣没有什么意义，除非您喜欢名称难以阅读：它只是部分复制了作用域名称。我会把它改名为iterator。

现在的问题是，它试图使用列表中的一个成员head_来初始化自己，但它没有访问列表的权限来提取头。您可能想以标准容器为例，通过列表中的一个成员创建一个迭代器：

iterator begin() {return iterator(head_);}

并相应地修改迭代器的构造函数。

在C++11中，这意味着用户通常根本不需要写出讨厌的限定名；你可以用得到一个迭代器

auto it = list.begin();

最后，从迭代器的operator*和operator++中移除参数。由于它们是成员函数，所以它们的操作数以this的形式隐式传递，而不是显式作为参数传递。

相关文章：