C++模板实现的单向链表

#ifndef DDXXLISTS_H
#define DDXXLISTS_H
#include <iostream>
using namespace std;
template<typename Type>
class Lists
{
public:
Lists();
Lists(int nSize);
~Lists();
public:
struct Node
{
Type  e;
Node* next;
Node()
{
}
Node(Type _e)
{
e = _e;
next = NULL;
}
};
public:
bool insert(Type e,int pos);
bool add(Type e);
bool erase(int pos);
void clear();
bool isEmpty();
int getLength();
void print();
private:
Node* m_head;
int m_nLength;
};

template<typename Type> Lists<Type>::Lists()
{
Node *pPos = new Node;
pPos->next = NULL;
m_head = pPos;
m_nLength = 0;
}

template<typename Type> Lists<Type>::Lists(int nSize)
{
m_nLength = nSize;
Node *pPos = new Node;
pPos->next = NULL;
m_head = pPos;
m_nLength = nSize;

for (int i=0;i<m_nLength;i++)
{
pPos->next = new Node;
pPos = pPos->next;
}
}

template<typename Type> bool Lists<Type>::insert(Type e,int pos)
{
if (pos >= m_nLength)
{
cout<<"The position to insert out of range"<<endl;
return false;
}
else
{
Node *ptr = m_head;
int cnt = 0;
while(cnt <= pos)
{
ptr = ptr->next;
cnt++;
}
Node *pNew = new Node(e);
pNew->next = ptr->next;
ptr->next = pNew;

m_nLength++;
return true;
}
}

template<typename Type> bool Lists<Type>::add(Type e)
{
Node *pNew = new Node(e);
if (pNew == NULL)
{
cout<<"allocate memory for new node failed"<<endl;
return false;
}
else
{
Node *ptr = m_head;
while(ptr->next != NULL)
{
ptr = ptr->next;
}
ptr->next = pNew;
pNew->next = NULL;
m_nLength++;
return true;
}
}

template<typename Type> bool  Lists<Type>::erase(int pos)
{
if (pos >= m_nLength)
{
cout<<"The position to delete out of range"<<endl;
return false;
}
else
{
Node *ptr = m_head;
int i = 0;
while( i<pos )
{
ptr = ptr->next;
i++;
}
Node *pdel = ptr->next;
ptr->next = ptr->next->next;
delete pdel;
pdel = NULL;
m_nLength--;

return true;
}
}

template<typename Type> void Lists<Type>::print()
{
if(m_nLength ==0)
cout<<"The list is empty"<<endl;
Node *ptr = m_head;
while(ptr->next!= NULL)
{
ptr = ptr->next;
cout<<"element value:"<<ptr->e<<endl;
}
}

template<typename Type> int Lists<Type>::getLength()
{
return m_nLength;
}
template<typename Type> bool Lists<Type>::isEmpty()
{
return m_head->next == NULL;
}

template<typename Type> void Lists<Type>::clear()
{
Node *ptr = m_head->next;
Node *ptmp = NULL;
while(ptr != NULL)
{
ptmp = ptr;
ptr = ptr->next;
delete ptmp;
ptmp = NULL;
m_nLength--;
}
m_head->next = NULL;

}
template<typename Type> Lists<Type>::~Lists()
{
Node *ptr = m_head;
Node *ptmp = NULL;
while(ptr->next != NULL)
{
ptmp = ptr;
ptr = ptr->next;
delete ptmp;
ptmp = NULL;
}
delete ptr;
ptr = NULL;
}
#endif

#include <iostream>
#include "Lists.h"
using namespace std;
void main()
{
cout<<"*************************Test list init***************************"<<endl;
Lists<int> Lisa;
cout<<"List's length is:"<<Lisa.getLength()<<endl;
cout<<"List is empty:"<<Lisa.isEmpty()<<endl;

cout<<"*************************Test list add element********************"<<endl;
Lisa.add(1);
Lisa.add(2);
Lisa.add(3);
Lisa.add(4);
Lisa.add(5);
Lisa.print();
cout<<"List's length is:"<<Lisa.getLength()<<endl;
cout<<"List is empty:"<<Lisa.isEmpty()<<endl;

cout<<"*************************Test list insert*************************"<<endl;
Lisa.insert(-1,0);
Lisa.insert(11,2);
Lisa.insert(100,6);
Lisa.print();
cout<<"List's length is:"<<Lisa.getLength()<<endl;
cout<<"List is empty:"<<Lisa.isEmpty()<<endl;

cout<<"*************************Test list erase**************************"<<endl;
Lisa.erase(0);
Lisa.erase(2);
Lisa.erase(5);
Lisa.print();
cout<<"List's length is:"<<Lisa.getLength()<<endl;
cout<<"List is empty:"<<Lisa.isEmpty()<<endl;

cout<<"*************************Test list clear**************************"<<endl;
Lisa.clear();
Lisa.print();
cout<<"List's length is:"<<Lisa.getLength()<<endl;
cout<<"List is empty:"<<Lisa.isEmpty()<<endl;
}