Question

I am trying to implement a Circular Doubly Linked List, and I have no probably with the Linked List implementation itself. The problem I am having is allowing it to take generic parameters using templates. I have checked several tutorials dealing with templates, but I haven’t found anything specific to what I am trying to do.

I believe I have worked out most of the errors, but I am still getting the errors:

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
      ]

Here is my code:

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

As far as I’m aware I haven’t done much wrong, I just need to correct those few errors. If I have done something majorly wrong if you could please point it out to me, or direct me to an appropriate resource it would be much appreciated.

Thanks in advance.

Answer 1

The error is pretty clear. You are using Node in several places inside LinkedList without using it with template parameters.

For example:

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

Should be

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

And the same goes for the other places, except inside the Node class declaration and Node function definitions (and in function definitions, you have to have it for the first one).