Question

我正在尝试实现一个循环双向链接列表，我可能没有链接列表实现本身。我遇到的问题是允许它使用模板获取通用参数。我已经检查了几个处理模板的教程，但是我没有找到任何特定于我想要做的事情。

我相信我已经解决了大部分错误，但我仍然遇到错误：

linkedlist.h(37): error C2955: 'Node' : use of class template requires template argument list
linkedlist.h(9) : see declaration of 'Node'
main.cpp(6) : see reference to class template instantiation 'LinkedList<T>' being compiled
      with
      [
          T=int
      ]

这是我的代码：

LinkedList.h：

#ifndef LINKEDLIST_H
#define LINKEDLIST_H

#include <iostream>

//node
template <class T>
class Node
{
private:

public:
    bool first;             //boolean tag 
    Node * next;            //pointer to the next node
    Node * prev;            //pointer to the prev node
    T data;                 //placeholder for generic data

    Node(T d);          //constructor
};

template <class T>
Node<T>::Node(T d)
{
    next = NULL;
    prev = NULL;
    data = d;
    first = false;
}

//a circular doubly-linked list
template <class T>
class LinkedList
{
private:

public:
    Node * p;                   //reference to the current node

    LinkedList();               //constructor

    bool empty();               //returns true if the list is empty, false otherwise
    int size();                 //returns the number of elements in the list    
    void insertBefore(T d); //inserts a node before the current node
    void insertAfter(T d);  //inserts a node after the current node
    void remove();              //removes the current node
    void moveAhead();           //moves to the next node
    void moveBack();            //moves to the previous node
    T access();             //returns the data of the current node
    void listContents();        //displays the data of every element in the list starting with the current
};

template <class T>
LinkedList<T>::LinkedList()
{
    p = NULL;
}

template <class T>
bool LinkedList<T>::empty()
{
    if (p == NULL)
    {
        std::cout << "List is Empty.\n";
        return true;
    }
    else
        return false;
}

template <class T>
int LinkedList<T>::size()
{
    if (p == NULL)
    {
        return 0;
    }
    if (p->next == p)
    {
        return 1;
    }
    else
        return 2; //placeholder
}

template <class T>
void LinkedList<T>::insertBefore(T d)
{
    Node *q, *t;
    if (p == NULL)
    {
        p = new Node<T>(d);
        p->next = p;
        p->prev = p;
        //std::cout << d << " inserted.\n";
    }
    else
    {
        if (p-> next == p)
        {
            q = new Node<T>(d);
            q->next = p;
            q->prev = p;
            p->next = q;
            p->prev = q;
            //std::cout << d << " inserted.\n";
        }
        else
        {
            q = p->prev;
            t = new Node<T>(d);
            p->prev = t;
            q->next = t;
            t->next = p;
            t->prev = q;
            //std::cout << d << " inserted.\n";
        }
    }
}

template <class T>
void LinkedList<T>::insertAfter(T d)
{
    Node *q, *t;
    if (p == NULL)
    {
        p = new Node<T>(d);
        p->next = p;
        p->prev = p;
        //std::cout << d << " inserted.\n";
    }
    else
    {
        if (p-> next == p)
        {
            q = new Node<T>(d);
            q->next = p;
            q->prev = p;
            p->next = q;
            p->prev = q;
            //std::cout << d << " inserted.\n";
        }
        else
        {
            q = p->next;
            t = new Node<T>(d);
            p->next = t;
            q->prev = t;
            t->next = q;
            t->prev = p;
            //std::cout << d << " inserted.\n";
        }
    }
}

template <class T>
T LinkedList<T>::access()
{
    if (p == NULL)
    {
        std::cout << "The list is empty. No data to be accessed.\n";
        return NULL;
    }
    else
        return p->data;
}

template <class T>
void LinkedList<T>::remove()
{
    if (p == NULL)
        std::cout << "The list is empty. No node exists to be removed.\n";
}

template <class T>
void LinkedList<T>::moveAhead()
{
    p = p->next;
}

template <class T>
void LinkedList<T>::moveBack()
{
    p = p->prev;
}

template <class T>
void LinkedList<T>::listContents()
{
    if (p == NULL)
    {
        std::cout << "This list is empty, there are no elements to be displayed.";
    }
    else
    {
        Node *q;
        p->first = true;;
        q = p;
        while (!q->next->first)
        {
            //std::cout << q->data << ", ";
            q = q->next;
        }
        //std::cout << q->data << ".\n";
        p->first = false;
    }
}

#endif

main.cpp中：

#include <iostream>
#include "LinkedList.h"

int main()
{
    LinkedList<int> list;

    list.empty();
    std::cout << "p list size is: " << list.size() << std::endl;
    list.remove();
    list.access();
    list.insertBefore(3);
    list.insertBefore(2);
    list.moveBack();
    list.insertBefore(1);
    list.moveBack();
    list.moveAhead();
    list.moveAhead();
    list.insertAfter(5);
    list.insertAfter(4);
    list.moveBack();
    list.moveBack();
    list.listContents();

    system("PAUSE");
    return 0;
}

据我所知，我没有做太多错误，我只需纠正这些错误。如果我做了一件非常重要的事情，如果你能指出我，或者指示我找一个合适的资源，我将非常感激。

提前致谢。

Answer 1

错误很清楚。您在Node内的多个位置使用LinkedList，而不使用模板参数。

例如：

template <class T>
void LinkedList<T>::insertBefore(T d)
{
    Node *q, *t;

应该是

template <class T>
void LinkedList<T>::insertBefore(T d)
{
    Node<T> *q, *t;

对于其他地方也是如此，除了在Node类声明和Node函数定义中（并且在函数定义中，你必须拥有它第一个）。

C ++ Template Generics（模板参数列表）

1 个答案: