Построить двусвязный список сведений о высших учебных заведениях

#ifndef _List_h_
#define _List_h_
 
#include <iostream>
 
 
 
// ==================================================================
// Узел
template <class T>
struct Node
{
    T           value;      // Значение
    Node<T>    *prev;       // Указатель на предыдущий узел
    Node<T>    *next;       // Указатель на следующий узел
};
 
// Список
template <class T>
class List
{
private:
    Node<T>                *m_head;     // Указатель на "голову" списка
    Node<T>                *m_tail;     // Указатель на "хвост" списка
    unsigned int            m_size;     // Размер списка (количество узлов)
 
public:
    List();
    ~List();
 
    void PushBack(const T &value);      // Добавление нового узла со значением value в конец списка
    void PushFront(const T &value);     // Добавление нового узла со значением value в голову списка
    bool PopBack();                     // Удаление последнего узла списка
    bool PopFront();                    // Удаление первого узла списка
 
    unsigned int Size() const;          // Возвращает размер списка (кол-во узлов)
    bool IsEmpty() const;               // Пустой список?
 
    void PrintList() const;             // Печать списка
 
private:        // Запрещенные методы
    List(const List<T> &list);
    const List<T> &operator=(const List<T> &list);
};
// ==================================================================
 
 
template <class T>
List<T>::List()
{
    m_head = m_tail = NULL;
    m_size = 0;
}
 
template <class T>
List<T>::~List()
{
    while ( this->PopBack() )
        ;
}
 
template <class T>
void List<T>::PushBack(const T &value)
{
    if (!m_tail)    // Если нет хвоста списка, т.е. список пуст, то ...
    {
        m_tail = new Node<T>;
 
        m_tail->value = value;
        m_tail->prev = m_tail->next = NULL;
 
        m_head = m_tail;
    }
    else
    {
        m_tail->next = new Node<T>;
 
        m_tail->next->prev = m_tail;    // Свяжем новый узел с хвостом
        m_tail = m_tail->next;          // Изменим хвост списка
 
        m_tail->value = value;
        m_tail->next = NULL;
    }
 
    ++m_size;
}
 
template <class T>
void List<T>::PushFront(const T &value)
{
    if (!m_head)    // Если нет головый списка, т.е. список пуст, то ...
    {
        m_head = new Node<T>;
 
        m_head->value = value;
        m_head->prev = m_head->next = NULL;
 
        m_tail = m_head;
    }
    else
    {
        m_head->prev = new Node<T>;
 
        m_head->prev->next = m_head;    // Свяжем новый узел с головой списка
        m_head = m_head->prev;          // Изменим голову списка
 
        m_head->value = value;
        m_head->prev = NULL;
    }
 
    ++m_size;
}
 
template <class T>
bool List<T>::PopBack()
{
    if (m_tail)     // Если есть последний узел
    {
        if (m_size == 1)   // Если в списке остался один узел, то ...
        {
            delete m_tail;
            m_tail = m_head = NULL;
        }
        else
        {
            m_tail = m_tail->prev;      // Перейдем в предыдущий узел
 
            delete m_tail->next;        // Удалим хвост
            m_tail->next = NULL;
        }
 
        --m_size;
        return true;            // Узел успешно удален
    }
    else            // Список пуст
    {
        return false;   // Узел не удален
    }
}
 
template <class T>
bool List<T>::PopFront()
{
    if (m_head)     // Если есть список
    {
        if (m_size == 1)   // Если в списке остался один узел
        {
            delete m_head;
            m_head = m_tail = NULL;
        }
        else
        {
            m_head = m_head->next;
 
            delete m_head->prev;
            m_head->prev = NULL;
        }
 
        --m_size;
        return true;
    }
    else
    {
        return false;
    }
}
 
template <class T>
unsigned int List<T>::Size() const
{
    return m_size;
}
 
template <class T>
bool List<T>::IsEmpty() const
{
    return (!m_head);
}
 
template <class T>
void List<T>::PrintList() const
{
    const Node<T>       *node = m_head;
 
    std::cout << "NULL - ";
    while (node)
    {
        std::cout << node->value << " - ";
        node = node->next;
    }
    std::cout << "NULL" << std::endl;
}
 
 
#endif