Разработать шаблон класса для работы с двунаправленным некольцевым списком

#include <iostream>
 
using namespace std;
 
template <typename T>
class ListD
{
    struct Node
    {
        T data;
        Node *next, *prev;
        Node(T d, Node *n = 0, Node *p = 0):data(d), next(n), prev(p) {}
    };
    Node *head;
public:
    ListD(Node *h = 0):head(h){}
    ~ListD();
    bool isEmpty();
    void insertAfter(Node *pre, T d);
    void removeAfter(Node *pre);
    void pushFront(T d);
    T popFront();
    void print();
    Node *search(T d);
    void create(int k);
    void createFrom(List<T> *L1);
};
 
template <typename T>
ListD<T>::~ListD()
{
    while (!isEmpty())
       popFront();
}
 
template <typename T>
bool ListD<T>::isEmpty() 
{
    return !head;
}
 
template <typename T>
void ListD<T>::insertAfter(Node *pre, T d) 
{ 
    if(!pre) return;
    Node *newNode = new Node(d,0,0);
    newNode->prev = pre;
    newNode->next = pre->next;
    pre->next = newNode;
}
 
template <typename T>
void ListD<T>::removeAfter(Node *pre)
{
    if (!pre || !pre->next) return;
    Node *tmp = pre->next; 
    if (!tmp->next)
    {
        pre->next = NULL;
    }
    else
    {
        tmp->next->prev = pre;
        pre->next = tmp->next;
    }
    delete tmp; 
}
 
template <typename T>
void ListD<T>::pushFront(T d)
{
    Node *newNode = new Node(d,0,0);
    if(!head) {
        head = newNode;
        return;
    }
    newNode->next = head;
    newNode->prev = NULL;
    head->prev = newNode;
    head = newNode;
}
 
template <typename T>
T ListD<T>::popFront()
{
    T data;                 
    if(!head) return data;
    Node *tmp = head;
    data = head->data;
    if(head->next) {
        head = head->next;
        head->prev = NULL;
        delete tmp;
        return data;
    }
    delete tmp;
    head = NULL;
    return data;
}
 
template <typename T>
typename ListD<T>::Node* ListD<T>::search(T d)
{
    if(!head) return NULL;
    Node* cur = head;
    while(cur) {
        if(cur->data == d) return cur;
        cur = cur->next;
    }
    return NULL;
}
 
 
template <typename T>
void ListD<T>::print()
{
    if(!head) return;
    Node *cur  = head;
    while(cur) {
        cout << cur->data << "; ";
        cur = cur->next;
    }
    cout << endl;
}
 
template <typename T>
void ListD<T>::create(int k)
{
    T d;
    for (int i = 1; i <= k; i++)
    {
        cout << "Enter " << i << "-i element: ";
        cin >> d;
        pushFront(d);
    }
}
template <typename T>
void ListD<T>::createFrom(List<T> *L1)
{
    pushFront(L1->popFront());
    Node *cur  = head;
    while (!L1->isEmpty())
    {
       insertAfter(cur, L1->popFront());
       cur = cur->next;
    }
}

int main()
{
        
 
    ListD<string> *L = new ListD<string>();
    L->createFrom(L1);
    L->print();
    
    system("PAUSE");
    return EXIT_SUCCESS;
}