c++ 模板 链表实现

#include <iostream>

using namespace std;

class A;

template<class Node>
class ListNode
{
    public:
        //explicit ListNode();
        ListNode();
        ~ListNode();
        ListNode *next;
        Node info;
};

template<class Node>
ListNode<Node>::ListNode()
{
    
}

template<class Node>
ListNode<Node>::~ListNode()
{
}

class A
{    
    public:
        A();
        A(int a);
        A(const A& a);
        ~A();
        bool operator ==(const A& a1);
        int id;

};

A::A()
{
}

A::A(int a )
{
    id = a ;
    
}

A::A(const A& a)
{
    id = a.id;

    cout<<"test"<<endl;

}

A::~A()
{

}

bool A::operator ==(const A& a1)
{

}

template<class T >
class List
{
    public:
        List();
        ~List();
        void insert(const T& item);
        void insert(const T& item,int pos);
        void append(const T& item);
        ListNode<T> *reverse();
        //int find(const T& item);
        int find_first(const T& item);
        int find_end(const T& item);
        // remove(const T& item);
        bool remove(int pos);

        void printList();
        void printList(ListNode<T> *list);

        ListNode< T> *head;
        int position ;
};

template<class T>
List<T>::List()
{
    head = NULL;
    position = 0;
}

template<class T>
List<T>::~List()
{
}

template<class T>
void List<T>::insert(const T& item)
{

    ListNode<T> *listNode= new ListNode<T>();
    listNode->next = head;
    listNode->info = item;

    head = listNode;

    position +=1;
}

template<class T>
void List<T>::insert(const T& item,int pos)
{
    if (position<-1 || pos >position )
    {
        return;
    }

    if(pos ==0)
    {
        insert(item);
    }
    else
    {
        ListNode<T> *tmp = head;

        for (int i = 0; i < pos; i++)
        {
            tmp = tmp->next;
        }

        ListNode<T> *node = tmp->next;

        ListNode<T> *listNode= new ListNode<T>();
        listNode->next = node;
        listNode->info = item;

        tmp->next = listNode;

        position +=1;
    }
}

template<class T>
void List<T>::append(const T& item)
{
    if(head !=NULL)
    {
        ListNode<T> *tmp = head;

        while(tmp->next !=NULL)
        {
            tmp = tmp->next;
        }

        ListNode<T> *listNode= new ListNode<T>();
        listNode->next = NULL;
        listNode->info = item;

        tmp->next = listNode;

        position +=1;
    }
    else
    {
        insert(item);
    }
}

/*template<class T>
void List<T>::remove(const T& item)
{
    ListNode<T> *tmp = head;

    while(tmp !=NULL)
    {
        if(tmp->info == item)
        {
            
        }

        tmp = tmp->next;
    }
}*/

template<class T>
bool List<T>::remove(int pos)
{
    if(head == NULL || pos<-1 || pos>position)
        return false;

    if(head !=NULL)
    {
        ListNode<T> *currentNode =  head;

        int i = 0;

        while(currentNode !=NULL)
        {
            i++;

            if(i == pos)
                break;

            currentNode = currentNode->next;
        }

        ListNode<T> *tmp = currentNode->next;

        currentNode->next = tmp->next->next;

        delete tmp;
        tmp = NULL;

        position-=1;

    }
}

template<class T>
int List<T>::find_first(const T& item)
{
    if(head != NULL)
    {
        ListNode<T> *currentNode = head;
        int i = 0;

        while(currentNode !=NULL)
        {
            i++;
            if(currentNode->info == item)
            {
                cout<<item<<endl;
                break;
            }

            currentNode = currentNode->next;
    }

        return i;

    }else
    {
        return -1;
    }
}

template<class T>
int List<T>::find_end(const T& item)
{
    if(head != NULL)
    {
        ListNode<T> *currentNode = head;
        int i = 0;
        int pos = 0;

        while(currentNode !=NULL)
        {
            i++;
            if(currentNode->info == item)
            {
                pos = i;
            }

            currentNode = currentNode->next;
    }

        return pos;

    }else
    {
        return -1;
    }
}

template<class T>
ListNode<T> *List<T>::reverse()
{
    if(head !=NULL)    
    {
        ListNode<T> *tmp = head;
        ListNode<T> *newList  =  new ListNode<T>();
        newList->info = tmp->info;
        newList->next = NULL;

        ListNode<T> *swap;

        while(tmp->next !=NULL)
        {
            swap = newList->next;
            newList->next = tmp->next;
            tmp->next = tmp->next->next;
            newList->next->next = swap;
        }

        return newList;

    }
    else
    {
        return NULL;
    }
}


template<class T>
void List<T>::printList()
{

    ListNode<T> *tmp = head;

    while(tmp !=NULL)
    {
        cout<<tmp->info<<endl;
        tmp = tmp->next;
    }
}

template<class T>
void List<T>::printList(ListNode<T> *list)
{

    ListNode<T> *tmp = list;

    while(tmp !=NULL)
    {
        cout<<tmp->info<<endl;
        tmp = tmp->next;
    }
}


int main()
{
    List<int> *list = new List<int>;

    for (int i = 0; i < 10; i++)
    {
        list->insert(i);
    }

    list->insert(12,0);
    list->insert(0,2);
    list->insert(5,3);
    list->insert(5,7);

    list->append(122);
    list->append(130);

    ListNode<int> *node = new ListNode<int>();

    ListNode<int> *tmp = node;

    cout<<"find first = "<<list->find_first(5)<<endl;
    cout<<"find end = "<<list->find_end(5)<<endl;

    list->remove(5);
    list->remove(6);

    list->printList();

    cout<<"*******************************************************"<<endl;


    ListNode<int> *tmplist = list->reverse();

    list->printList(tmplist);


    delete list;


    List<A> *alist = new List<A>;

    for(int i=0;i<5;i++)
    {
        A a(i);
        alist->insert(a);
    }
}

以上是使用模板实现的数据结构