Создать шаблонный класс библиотека на основе односвязного списка

//Title of this code
//g++  4.9.2
 
#include <iostream>
#include <algorithm> 
 
 
// никто не знает о существовании этой структуры
// я её только что придумал
struct data
{
    int v;
};
 
int main()
{
 
    std::cout << "Hello, world!\n";
 
    //создаем массив таких структур
    data arr[] 
        = {32, 71, 12, 45, 26, 80, 53, 33 };
    
    std::cout << "source: ";
    for(const auto& i: arr)
        std::cout << i.v << ", ";
    std::cout<< '\n';
 
    // создаем предикат
    // он определяет правила, 
    // по которым мы хотим выполнять сортировку
    const auto predicat 
        = [](const data& i, const data& j){ return i.v < j.v; };
 
 
    // функция сортировки понятия не имеет, что это за структура data
    // однако, благодаря предикату, 
    // тем не менее, она может выполнить сортировку
    std::sort( arr, arr + 8, predicat );
 
    // таким образом, единожны описанная шаблоно-функция 
    // благодаря предикатам может сортировать любые данные
    // в том числе такие, о типах которых она ничего не знает
 
 
    std::cout << "sorted: ";
    for(const auto& i: arr)
        std::cout << i.v << ", ";
    std::cout<< '\n';
}

#include <iostream>
#include <cstring>
 
template<typename T>
struct node {
    T val;
    node<T>* next;
};
 
template<typename T>
class single_list {
private:
    node<T>* head;
    node<T>* tail;
    size_t   cnt;
public:
    single_list(void):head(NULL),
                      tail(NULL), 
                      cnt(0){}
    ~single_list(){
        this->clear();
    }
    single_list(const single_list&);
    single_list& operator = (const single_list&);
public:
    //добавление элемента в конец
    bool add_back(const T& val){
        node<T>* p = new_node(val);
        if(p != NULL){
            if(head == NULL)
                head = tail = p;
            else {
                tail->next = p;
                tail = p;
            }
        }
        return (p != NULL);
    }
 
    //сортировка
    template<typename Cmp>
    void sort(Cmp cmp){
        head = _merge_sort(head, &tail, cmp);
    }
 
    //удаление всех элементов
    void clear(void){
        node<T>* tmp;
        while(head != NULL){
            tmp  = head;
            head = head->next;
            delete tmp;
        }
        tail = NULL;
        cnt  = 0;
    }   
 
    size_t   size(void) const { return cnt; }
    node<T>* begin(void){ return head; }
    node<T>* begin(void) const { return head; }
private:
    node<T>* new_node(const T& val){
        node<T>* p = new (std::nothrow) node<T>();
        if(p != NULL){
            p->val  = val;
            p->next = NULL;
            ++cnt;
        }
        return p;
    }
 
    //сортировкa слиянием
    template<typename Cmp>
    node<T>* _merge_sort(node<T>* lst, node<T>** ptail, Cmp cmp) {
        if((lst == NULL) || (lst->next == NULL))
            return lst;
        node<T>* ptr, *next, *end;
        node<T>* first = lst;
        node<T>* last  = lst;
 
        ptr = next = end = NULL;
        for(node<T>* p = lst; (p != NULL) && (p->next != NULL); p = p->next->next) {
            last  = first;
            first = first->next;
        }
        last->next = NULL;
 
        lst   = _merge_sort(lst,   ptail, cmp);
        first = _merge_sort(first, ptail, cmp);
 
        while((lst != NULL) || (first != NULL)){ 
            if(first == NULL) {
                next = lst;
                lst  = lst->next;
            } else if(lst == NULL){
                next  = first;
                first = first->next;
            } else if(cmp(lst->val, first->val)){
                next = lst;
                lst  = lst->next;
            } else {
                next  = first;
                first = first->next;
            }
 
            if(ptr == NULL)
                ptr = next;
            else
                end->next = next;
            end = next;
        }
        *ptail = end;
        return ptr;
    }
};
 
//----------------------------------------------------------------------------
 
typedef struct {
    char l_name[16];
    int  year;
} book;
 
struct book_cmp {
    bool operator () (const book& a, const book& b)const{
        int res = strcmp(a.l_name, b.l_name);
        return ((res < 0) || (! res && (a.year < b.year)));
    }
};
 
int main(void){
    const size_t N = 8;
    const book arr[N] = {
        {"wwww", 1997}, {"aaaa", 2000}, {"aaaa", 1997}, {"wwww", 1965},
        {"wwww", 1993}, {"cccc", 1997}, {"cccc", 1993}, {"aaaa", 1999}
    };
 
    single_list<book> lst;
    for(size_t i = 0; i < N; ++i)
        lst.add_back(arr[i]);
 
    lst.sort(book_cmp());
    for(const node<book>* p = lst.begin(); p != NULL; p = p->next)
        std::cout << p->val.l_name << ' ' << p->val.year << std::endl;
    lst.clear();
    return 0;
}