C++链表模板

#ifndef CHAINLIST_H
#define CHAINLIST_H

#include <memory>

template<typename Type>  //声明
class ChainList;

template<typename Type>
class Node{
public:
    Node(Type&);
    friend class ChainList<Type>;  //友元类，以访问其私有数据
private:
    Type data;
    Node *next;
};

template<typename Type>
Node<Type>::Node(Type &item):data(item) //构造函数
{
    next = 0;
}

template<typename Type>
class ChainList{
public:
    ChainList():front(0),_size(0){}
    ~ChainList();
    void isEmpty(){return front==0;}
    ChainList& remove(int, Type&);
    ChainList& insert(int,Type&);
    bool find(int, Type&);
    int search(Type&);
    int size(){return _size;}
private:
    int _size;
    Node<Type> *front;
};

template<typename Type>
ChainList<Type>::~ChainList()
{
    Node<Type> *p;
    while(front) //节点一直指向某个地址则不断删除释放内存
    {
        p = front->next;
        delete front;
        front = p;
    }
};


template<typename Type>
ChainList<Type>& ChainList<Type>::remove(int k,Type& x)
{
    if (k>_size || k<1) //k在范围外无法删除
    {
        cerr<<"Out of memory!"<<endl;
        exit(-1);
    }
    Node<Type> *p = front; //指向首节点
    if(k==1)               //如果k为1，则删除首节点   
        front = front->next;
    else
    {
        Node<Type> *q = front;
        for(int index=1;index<k-1&&q;index++) //找到第k-1个节点
            q=q->next;
        if(!q||!q->next)  //如果不存在第k个节点，无法删除
        {
            cerr<<"Out of memory!"<<endl;
            exit(-1);
        }
        p = q->next; //将p指向第k个节点，将后续节点连起来
        q->next = p->next;
    }
    x = p->data;  //存储待删除节点的
    --_size;
    delete p; //删除当前节点
    return *this;
}

template<typename Type>
ChainList<Type>& ChainList<Type>::insert(int k, Type& item)
{
    if (k<0) //0代表第一个位置
    {
        cerr<<"Out of memory!"<<endl;
        exit(-1);
    }
    Node<Type> *q = front;
    for (int index=1;index<k && q;index++) //找到第k个元素
    {
        q=q->next;
    }
    if(k>0&&!q)
    {
        cerr<<"Out of memory!"<<endl;
        exit(-1);
    }   
    Node<Type> *p = new Node<Type>(item);
    if(k)
    {
        p->next = q->next;
        q->next = p;
    }
    else //直接在首节点插入
    {
        p->next = front;
        front = p;
    }
    ++_size;
    return *this;
}

template<typename Type>
bool ChainList<Type>::find(int k, Type &x)
{
    if (k<1) //超出范围，找不到
    {
        return false;
    }
    Node<Type> *p = front;
    int index = 1;
    while(index < k&&!p) //找到第k个节点
    {
        p = p->next;
        ++index;
    }
    if(p) //不为空，则表示找到
    {
        x = p->data;
        return true;
    }
    return false;
}

template<typename Type>
int ChainList<Type>::search(Type &x)
{
    Node<Type> *p = front;
    int index = 1;
    while(p && p->data !=x){ //找到x在链表中
        p = p->next;
        index++;
    }
    if(p)
    {
        return index;
    }
    return 0; //已经到链表尾，未找到
}

#endif