Двусвязный кольцевой список

#include "stdafx.h"
#include <cstdlib>
#include <iostream>
 
using namespace std;
 
struct node //элемент списка
{
       public:
       unsigned int data; //поле данных элемента списка */Беззнаковые целые числа (unsigned int)/*
       node* next; //поле, указывающее на следующий элемент списка
       node* prev; //поле, указывающее на предыдущий элемент списка
};
 
class mylist //класс списка
{
      public:
      node* head; //указатель на головной элемент списка
      mylist(); //стандартный конструктор списков
      void ins(int, node*); //добавление элемента
      void del(node*); //удаление элемента
      void show(); //просмотр списка
      node* search(int); //поиск в списке
};
 
mylist::mylist() //конструктор списка
{
      head = new node; //создание головного узла списка
      head->next = head; //по умолчанию только что созданный список состоит из одного головного узла
      head->prev = head;
}[

#ifndef LISTNODE_H
#define LISTNODE_H
 
template <typename NODETYPE> class List;
 
template <typename NODETYPE>
class ListNode
{
    friend class List<NODETYPE>;
 
public:
    ListNode(const NODETYPE &);
    NODETYPE getData() const;
private:
    NODETYPE data;
    ListNode<NODETYPE> *nextPtr;
};
 
template <typename NODETYPE>
ListNode<NODETYPE>::ListNode(const NODETYPE &info)
    :data(info),nextPtr(0)
{
}
 
template<typename NODETYPE>
NODETYPE ListNode<NODETYPE>::getData() const
{
    return data;
}
 
#endif

#ifndef LIST_H
#define LIST_H
 
#include "ListNode.h"
 
#include<iostream>
using std::cout;
 
template<typename NODETYPE>
class List
{
public:
    List();
    ~List();
    void insertAtFront(const NODETYPE &);
    void insertAtBack(const NODETYPE &);
    bool removeFromFront(NODETYPE &);
    bool removeFromBack(NODETYPE &);
    bool isEmpty() const;
    void print() const;
private:
    ListNode<NODETYPE> *firstPtr;
    ListNode<NODETYPE> *lastPtr;
 
    ListNode<NODETYPE> *getNewNode(const NODETYPE &);
};
 
template<typename NODETYPE>
List<NODETYPE>::List()
    :firstPtr(0),lastPtr(0)
{
}
 
template<typename NODETYPE>
List<NODETYPE>::~List()
{
    if(!isEmpty())
    {
        cout << "Destroying nodes...\n";
 
        ListNode<NODETYPE> *currentPtr = firstPtr;
        ListNode<NODETYPE> *tempPtr;
 
        while(currentPtr != 0)
        {
            tempPtr = currentPtr;
            cout << tempPtr->data << '\n';
            currentPtr = currentPtr->nextPtr;
            delete tempPtr;
        }
    }
 
    cout << "All nodes are destroyed\n\n";
}
 
template<typename NODETYPE>
void List<NODETYPE>::insertAtFront(const NODETYPE &value)
{
    ListNode<NODETYPE> *newPtr = getNewNode(value);
 
    if(isEmpty())
        firstPtr = lastPtr = newPtr;
    else
    {
        newPtr->nextPtr = firstPtr;
        firstPtr = newPtr;
    }
 
}
 
template<typename NODETYPE>
void List<NODETYPE>::insertAtBack(const NODETYPE &value)
{
    ListNode<NODETYPE> *newPtr = getNewNode(value);
 
    if(isEmpty())
        firstPtr = lastPtr = newPtr;
    else
    {
        lastPtr->nextPtr = newPtr;
        lastPtr = newPtr;
    }
 
}
 
template<typename NODETYPE>
bool List<NODETYPE>::removeFromFront(NODETYPE &value)
{
    if(isEmpty())
        return false;
    else
    {
        ListNode<NODETYPE> *tempPtr = firstPtr;
 
        if(firstPtr == lastPtr)
            firstPtr = lastPtr = 0;
        else
            firstPtr = firstPtr->nextPtr;
 
        value = tempPtr->data;
        delete tempPtr;
 
        return true;
    }
}
 
template<typename NODETYPE>
bool List<NODETYPE>::removeFromBack(NODETYPE &value)
{
    if(isEmpty())
        return false;
    else
    {
        ListNode<NODETYPE> *tempPtr = lastPtr;
 
        if(firstPtr == lastPtr)
            firstPtr = lastPtr = 0;
        else
        {
            ListNode<NODETYPE> *currentPtr = firstPtr;
 
            while(currentPtr->nextPtr != lastPtr)
                currentPtr = currentPtr->nextPtr;
 
            lastPtr = currentPtr;
            currentPtr->nextPtr = 0;
        }
 
        value = tempPtr->data;
        delete tempPtr;
        return true;
    }
}
 
template<typename NODETYPE>
bool List<NODETYPE>::isEmpty() const
{
    return firstPtr == 0;
}
 
template<typename NODETYPE>
ListNode<NODETYPE> *List<NODETYPE>::getNewNode(const NODETYPE &value)
{
    return new ListNode<NODETYPE>(value);
}
 
template<typename NODETYPE>
void List<NODETYPE>::print() const
{
    if(isEmpty())
    {
        cout << "The list is empty\n\n";
        return;
    }
    
    ListNode<NODETYPE> *currentPtr = firstPtr;
    cout << "The list is: ";
 
    while(currentPtr != 0)
    {
        cout << currentPtr->data << ' ';
        currentPtr = currentPtr->nextPtr;
    }
 
    cout << "\n\n";
}
 
#endif