Array类的应用：求范围2~n中的质数，n在程序运行时由键盘输入

//Array.h

const int null = 0;

enum ErrorType   //错误类型集合，共有三种错误：数组大小错误、内存分配错误和下标越界
{invalidArraySize,memoryAllocationError,indexOutOfRange};
char *errorMsg[]=
{
  "Invalid array size","Memory allocation error",
  "Invalid index:"
};
template<class T>
class Array
{
private:
   T *alist;
   int size;
   void Error(ErrorType error,int badIndex=0) const; //错误处理函数
public:
   Array(int sz=50);
   Array(const Array<T> &A); //拷贝构造函数
   ~Array(void);
   Array<T>& operator=(const Array<T> &rhs); //重载"=",使数组对象可以整体赋值
   T &operator[](int i);  //重载"[]",使Array对象可以起到C++普通数组的作用
   operator T*(void) const;  //重载T*，使Array对象可以起到C++普通函数的作用
   int ListSize(void) const;  //取数组大小
   void Resize(int sz);  //修改数组大小
};
 
template<class T>   //模板函数Error实现输出错误信息的功能
void Array<T>::Error(ErrorType error,int badIndex) const
{
   cout<<errorMsg[error];
   if(error==indexOutOfRange)
     cout<<badIndex;
   cout<<endl;
   exit(1);
}

template<class T>   //构造函数
Array<T>::Array(int sz)
{
  if(sz<=0)
     Error(invalidArraySize);
  size=sz;
  alist=new T[size]; //动态分配size个T类型的元素空间
  if(alist==null)   //如果分配内存不成功，输出错误信息
     Error(memoryAllocationError);
}

template<class T> //析构函数
Array<T>::~Array(void)
{
  delete [] alist;
}

template<class T>  //拷贝构造函数
Array <T>::Array(const Array<T>& X)
{
  int n=X.size;
  size=n;
  alist=new T[n];
  if(alist==null)
    Error(memoryAllocationError);
  T* srcptr=X.alist;
  T* destpr=alist;
  while(n--)
    *destptr++=*srcptr++;

}

template<class T>  //重载"="运算符
Array<T> & Array<T>::operator=(const Array<T> & rhs)
{
   int n=rhs.size;
   if(size!=n)
   {
     delete [] alist;
     alist=new T[n];
     if(alist==null)
        Error(memoryAllocationError);
     size=n;
   }
   T* desptr=alist;
   T* srcptr=rhs.alist;
   while(n--)
     *destptr++=*srcptr++;
   return *this;
}

template<class T>  //重载下标运算符
T& Array<T>::operator[](int n)
{
  if(n<0||n>size-1)
     Error(indexOutOfRange,n);
  return alist[n];
}

template <class T>  //重载指针转换运算符
Array<T>::operator T* (void) const
{
   return alist;
}

template <class T>   //取当前数组的大小
int Array<T>::ListSize(void) const
{
   return size;
}
template<class T>  //将数组大小改为sz
void Array<T>::Resize(int sz)
{
   if(sz<=0)
       Error(invalidArraySize );
   if(sz==size)
       return;
   T *newlist=new T[sz]; //申请新的数组内存
   if(newlist==null)
      Error(memoryAllocationError);
   int n=(sz<=size)?sz:size; //将sz与size中较小的一个赋值给n
   //将原有数组中前n个元素复制到新数组中
   T *srcptr=alist;
   T *destptr=newlist;
   while(n--)
      *destptr++=*srcptr++;
   delete[] alist;
   alist=newlist;
   size=sz;
}

 

//main函数

template <class T>   //取当前数组的大小
int Array<T>::ListSize(void) const
{
   return size;
}
template<class T>  //将数组大小改为sz
void Array<T>::Resize(int sz)
{
   if(sz<=0)
       Error(invalidArraySize );
   if(sz==size)
       return;
   T *newlist=new T[sz]; //申请新的数组内存
   if(newlist==null)
      Error(memoryAllocationError);
   int n=(sz<=size)?sz:size; //将sz与size中较小的一个赋值给n
   //将原有数组中前n个元素复制到新数组中
   T *srcptr=alist;
   T *destptr=newlist;
   while(n--)
      *destptr++=*srcptr++;
   delete[] alist;
   alist=newlist;
   size=sz;
}