Question

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

我想在List类中编写一个函数，它允许我增加到下一个名为getNext（）的元素以及一个getPrev（）;

我写了这样的getNext：

T* getNext(){return next;}

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

这是我的List类：

#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

Answer 1

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

Node* getNext() { return next; }

然后你可以得到价值。

如果你必须将它作为list本身的一部分，我不建议你需要参考Node next的{{1}}参数：< / p>

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);
}

Answer 2

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

所以它应该是

Node* getNext(){return next;}

Answer 3

因为它是Node结构的成员而getNext是List的成员。您应该从Node类型的对象访问它。

访问自定义链接列表类中的元素

3 个答案: