1

我正在构建自己的链表类，但在弄清楚如何编写一些函数来帮助我遍历这个列表时遇到了一些问题。这是我第一次从头开始构建链表，所以如果我的方法非常规，请告诉我什么可能更传统。

我想在 List 类中编写一个函数，该函数允许我递增到名为 getNext() 的下一个元素以及 getPrev();

我这样写getNext：

T* getNext(){return next;}

但是它告诉我 next 没有在范围内声明。我还想编写一个函数，让我可以访问和修改列表中的对象。我正在考虑使用方括号运算符，但首先我需要编写一个函数来返回数据成员。也许如果我在我的 pop 函数中采取类似的方法......现在考虑一下。但是，我仍然很感激任何建议。

这是我的列表类：

#ifndef LIST_H
#define LIST_H


//List Class
template <class T>
class List{
    struct Node {
        T data;
        Node *next;
        Node *prev;
        //Constructs Node Element
        Node(T t, Node* p, Node* n) { data = (t); prev = (p); next = (n); }
//      T *getNext() {return next;}
    };
        Node *head;
        Node *tail;
public: 
    //Constructor
    List() { head = NULL; tail=NULL; }
    //Destructor
    ~List() { 
        while(head){
            Node * temp(head);
            head = head->next;
            delete temp;
        }
    }
    //is empty
    bool empty() const {return (!head || !tail ); }
    operator bool() const {return !empty(); }
    //Push back
    void push_back(T data) {
        tail = new Node(data, tail, NULL);
        if(tail->prev) //if the node in front of tail is initilized
            tail->prev->next = tail;

        if( empty() )
            head = tail;
    }
    //Push front
    void push_front(T data) {
        head = new Node(data, NULL, head);
        if(head->next)//if the node following head is initilized
            head->next->prev = head;

        if( empty() )
         tail = head;
    };
    T pop_back() {
        if( empty() )
            throw("Error in List: List is empty\n");

        Node* temp(tail);
        T data(tail->data);
        tail = tail->prev;

        if( tail )
            tail->next = NULL;
        else
            head = NULL;

        delete temp;
        return data;
    }
    T pop_front() {
        if (empty())
            throw("Error in List: List is empty\n");

        Node* temp(head);
        T data(head->data);
        head = head->next;

        if(head)
            head->prev=NULL;
        else
            tail = NULL;

        delete temp;
        return data;
    }

    T getNext(){return next;}
};


#endif
4

3 回答 3

1

getNext应该是的一部分struct Node并返回一个Node*

Node* getNext() { return next; }

然后，您可以从中获得价值。

如果您必须将其作为list自身的一部分，我不建议您这样做，则需要采用Node您想要的参数next：

Node* getNext(Node* n) {return n->next;}

再次，我推荐第一个选项。

这是一个包含这两个的近似整个类：

template<typename T>
class List {
  public:
    struct Node {
      Node* next, prev;
      T data;

      //some constructor and stuff

      Node* Next() {return next;}
    }

    //some constructors and other functions

    Node* getNext(Node* _n) {return _n->Next();}
}

然后使用：

int main() {
  List<int> l;
  //add some stuff to the list
  //get the head of the list
  List<int>::Node* head = l.head; //or some corresponding function

  //then
  List<int>::Node* next = head->Next();
  //or
  List<int>::Node* next2 = l.getNext(head);
}
于 2013-10-15T17:53:26.477 回答
0

对于初学者来说getNext()，不应返回指向模板类的指针，而应返回指向Node结构的指针。

所以应该是

Node* getNext(){return next;}
于 2013-10-15T17:53:16.033 回答
0

因为它是Nodestruct 的成员并且getNext是List. 您应该从类型的对象访问它Node。

于 2013-10-15T17:54:34.643 回答