List-C++ template

 /*
*Ylist.h
*this is a  list template by array
*Ylist ADT list
*writer:chinanetboy ,QQ:44633197
*blog http://chinanetboy.bokee.com
*date:07/01/2008
*/
#ifndef H_Ylist
#define H_Ylist

#include <iostream>
#include <iomanip>
#include <cstring>
#include <cassert>
using namespace std;

//Ylist ADT list
template <class T>
class Ylist
{
public:
//1.constrator Ylist(),Ylist(int size)
Ylist();
Ylist(int size);

//2.copy constrator,=,destructor
Ylist(const Ylist<T>&);
const Ylist<T>& operator=(const Ylist<T>&);
~Ylist();

//3.IsFull(),IsEmpty(),GetSize(),MaxSize()
bool IsFull();
bool IsEmpty();
bool IsEqual(int index,const Ylist<T>&);
int  GetSize();
int  MaxSize();

//4.Insert(item);InsertAt(index,item),InsertEnd(item)
void Insert(const T& item);
void InsertAt(int index,const T& item);
void InsertEnd(const T& item);

//5.Remove(item),RemoveAt(index),RemoveEnd(),RemoveAll(void)
void Remove(const T& item);
void RemoveAt(int index);
void RemoveEnd();
void RemoveAll();

//6.FindItem(),ReplaceAt(),[]
int FindItem(const T& item);
void ReplaceAt(int index,const T& item);
const T& operator[](int index);

//7.print()
void print()const;

private:
T *list;
int maxsize;
int length;
};
//---------------------------------------------------------------
//1.constrator Ylist(),Ylist(int size)
template <class T>
Ylist<T>::Ylist(){
    maxsize=100;
    length=0;
    list=new T[maxsize];
    assert(list!=NULL);
}

template <class T>
Ylist<T>::Ylist(int size){
    if (size<0)
      {maxsize=100;}
    else
      {maxsize=size;}
   
    length=0;
    list=new T[maxsize];
    assert(list!=NULL);
}
//---------------------------------------------------------------
//2.copy constrator,=,destructor
template <class T>
Ylist<T>::Ylist(const Ylist<T>& r){
    maxsize=r.maxsize;
    length=r.length;
    list= new T[maxsize];
    assert(list!=NULL);
    for (int j=0;j<length;j )
    list[j]=r.list[j];
}
template <class T>
const Ylist<T>& Ylist<T>::operator=(const Ylist<T>& r){
    if(this!=&r){
    delete [] list;   
    maxsize=r.maxsize;
    length=r.length;
    list= new T[maxsize];
    assert(list!=NULL);
    for (int i=0;i<length;i )
    list[i]=r.list[i];
    }
    return *this;   
}

template <class T>
Ylist<T>::~Ylist(){
    delete [] list;   
}
//---------------------------------------------------------------
//3.IsFull(),IsEmpty(),GetSize(),MaxSize()
template <class T>
bool Ylist<T>::IsFull(){
     return (length==maxsize);
}

template <class T>
bool Ylist<T>::IsEmpty(){
      return (length==0);
}

template <class T>
int Ylist<T>::GetSize(){ return length;}

template <class T>
int Ylist<T>::MaxSize(){ return maxsize;}
//---------------------------------------------------------------
//4.Insert(item);InsertAt(index,item),InsertEnd(item)
template <class T>
void Ylist<T>::Insert(const T& item){
     if (length==maxsize)
        cerr<<"can not insert in a full list!/n";
     else
     {
     if (FindItem(item)!=-1)
        cerr<<"this item already exist!cannot be insert/n";    
     else
         list[length]=item;
         length ;        
     }
}

template <class T>
void Ylist<T>::InsertAt(int index,const T& item){
     if (0>index ||index>maxsize )      
        cerr<<"index out of range!/n";
     else
     if (length==maxsize)
        cerr<<"can not insert in a full list!/n";
     else
     {
         for(int i=length;length>index;i--)
         {list[i]=list[i - 1];}
         list[index]=item;
         length ;
     }
}
template <class T>
void Ylist<T>::InsertEnd(const T& item){
     if (length==maxsize)
        cerr<<"can not insert in a full list!/n";
     else
     {
         list[length]=item;
         length ;
     }    
}
//---------------------------------------------------------------
//5.Remove(item),RemoveAt(index),RemoveEnd(),RemoveAll()

template <class T>
void Ylist<T>::Remove(const T& item){
     int loc=FindItem(item);
     if (length==0)      
        cerr<<"this list is empty, remove fail!/n";
     if (loc==-1)
        cerr<<"this item not exist!cannot be remove/n";     
     else
     {
         for(int i=loc;i<length - 1;i )
              list[i]=list[i 1];
        length--;              
     }    
}

template <class T>
void Ylist<T>::RemoveAt(int index){
     if (0>index ||index>maxsize )     
        cerr<<"index out of range!/n";         
     else
     {
         for(int i=index;i<length - 1;i )
              list[i]=list[i 1];
        length--;              
     }    
}   

template <class T>
void Ylist<T>::RemoveEnd(){
    length--;
}


template <class T>
void Ylist<T>::RemoveAll(){
    length=0;
}
//---------------------------------------------------------------
//6.FindItem(),ReplaceAt(),[]

template <class T>
int  Ylist<T>::FindItem(const T& item){
     int loc;
     bool found=false;
     for (loc=0;loc<length;loc )
         if(list[loc]==item){
         found=true;
         break;
         }
     if (found)
            return loc;
     else
            return -1;  
}

template <class T>
void  Ylist<T>::ReplaceAt(int index,const T& item){
     if (0>index ||index>length )     
        cerr<<"index out of range!/n";         
     else
        list[index]=item;          
}

template <class T>
const T& Ylist<T>::operator[](int index){
    return list[index];
}

//---------------------------------------------------------------
//7.print()
template <class T>
void Ylist<T>::print()const{
     for(int ii=0;ii<length;ii ){
     cout<<list[ii]<<" ";
     }
     cout<<endl;
}
#endif

--------------------------------------------------------------------------------------------------------------
// compilerd ok with dev-c and vc 6.0
#include <cstdlib>
#include <iostream>
#include <cstring>
#include "Ylist.h"
using namespace std;
int main(int argc, char *argv[])
{
    cout<<"list class with array demo... /n";
    //1.constrator Ylist(),Ylist(int size) 构造函数测试
    Ylist<char> clist();        //Ylist()测试
    Ylist<string> slist(50);    //Ylist(int size)测试
    Ylist<int>    ilist1(50);        //Ylist(int size)测试
    Ylist<int>    ilist3(50);        //Ylist(int size)测试
    Ylist<int>    ilist4(50);        //Ylist(int size)测试
    //输入数据到ilist2
    int i;
    for(i=20;i>0;i--){
        ilist1.InsertEnd(i);
    }

    //2.copy constrator,=,destructor 复制控制测试
    //Ylist(const Ylist<T>&);
    //const Ylist<T>& operator=(const Ylist<T>&);
    //~Ylist();
    Ylist<int> ilist2(ilist1);    //复制构造函数Ylist(const Ylist<T>&)测试
    ilist3 = ilist2;            //重载operator=
    ilist1.print();           
    ilist2.print();
    ilist3.print();
    ilist4.print();
    //3.IsFull(),IsEmpty(),GetSize(),MaxSize()测试
    cout<<"ilist1.IsFull()="<<ilist1.IsFull()<<endl;//IsFull()测试
    cout<<"ilist4.IsEmpty()="<<ilist4.IsEmpty()<<endl;//IsEmpty()测试
    cout<<"ilist1.GetSize()="<<ilist1.GetSize()<<endl;//GetSize()测试
    cout<<"ilist1.MaxSize()="<<ilist1.MaxSize()<<endl;//MaxSize()测试
   
    //4.Insert(item);InsertAt(index,item),InsertEnd(item)测试
    ilist4.Insert(90);            //Insert(item)   
    ilist4.InsertAt(1,91);        //InsertAt(index,item)
    ilist4.InsertEnd(92);        //InsertEnd(item)
    ilist4.InsertEnd(88);        //InsertEnd(item)
    ilist4.InsertEnd(80);        //InsertEnd(item)
    ilist4.print();
    //5.Remove(item),RemoveAt(index),RemoveEnd(),RemoveAll(void)测试
    ilist4.Remove(92);
    ilist4.RemoveAt(2);
    ilist4.RemoveEnd();
    ilist4.print();
    ilist4.RemoveAll();
    ilist4.print();

    //6.FindItem(),ReplaceAt(),[]测试
    ilist4.InsertEnd(80);
    cout<<"FindItem(80)="<<ilist4.FindItem(80)<<endl;    //FindItem()
    cout<<"ilist4[1]="<<ilist4[1]<<endl;    //[]
    ilist4.print();
    ilist4.ReplaceAt(0,101);        //ReplaceAt()
   
    //7.print()
    ilist4.print();            //print()

    system("PAUSE");
    return EXIT_SUCCESS;
}