不行啊还是求大侠帮忙编译吧
照人家抄，可是无法编译，不知问题出在那里，谢谢了！
#ifndef ARRAY_CLASS
#define ARRAY_CLASS
#include <iostream.h>
#include <stdlib.h>
#ifndef NULL
const int NULL=0
#endif//NULL
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> &rhs);
T &operator[](int i);
operator T*(void) const;
int ListSize(void) const;
void Resize(int sz);
};
//类成员函数的实现：
template <class T>
void Array <T> ::Error(ErrorType error,int badIndex) const
{
cout < <errorMsg[error];//根据错误类型，输出相应的错误信息
//for indexOutOfRage,print the bad index
if(error==indexOutOfRange)
cout < <badIndex;//如果是下标越界错，输出错误的下标
cout < <endl;
exit(1);
}
//构造函数
template <class T>
Array <T> ::Array(int sz)
{
if(sz <=0)//sz为数组大小（元素个数），若小于0，则输出错误信息
Error(invalidArraySize);
size=sz;//将元素个数赋值给变量size
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)
{
//从对象X取得数组大小，并赋值给当前对象的成员
int n=X.size;
size=n;
//为对象申请内存并进行出错检查
alist=new T[n];
if(alist==NULL)//如果分配内存不成功，输出错误信息
Error(memoryAllocationError);
//从对象X复制数组元素到本对象
T* srcptr=X.alist;
T* destptr=alist;
while(n--)
*destptr++=*srcptr++;
}
//重载 "= "运算符，将对象rhs赋值给本对象，实现对象之间的整体赋值
template <class T>
Array <T> & Array <T> ::operator =(const Array <T> & rhs)
{
int n=rhs.size;//取rhs的数组大小
//如果本对象中数组大小与rhs不同，则删除数组原有内存，然后重新分配
if(size!=n)
{
delet [] alist;//删除数组原有内存
alist=new T[n];//重新分配n个元素的内存
if(alist==NULL)//如果分配内存不成功，输出错误信息
Error(memoryAllocationError);
size=n;//记录本对象的数组大小
}
//从rhs向本对象复制元素
T* destptr=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);
//返回下标为n的数组元素
return alist[n];
}
//重载指针转换操作符，将Array类的对象名转换为T类型的指针，
//指向当前对象中的私有数组。
//因而可以象使用普通数组首地址一样使用Arrary类的对象名
template <class T>
Array <T> ::operator T*(void) const
{
//返回当前对象中私有数组的首地址
return alist;
}
//取当前数组的大小
template <class T>
int Array <T> ::ListSize(void) const
{
return size;}
//将数组大小修改为sz
template <class T>
void Array <T> ::Resize(int sz)
{
//检查是否sz <=0
if(sz <=0)
Error(invalidArraySize);
//如果指定的大小与原有大小一样，什么也不做
if(sz==size) return;
//申请新的数组内存，并测试是否申请成功
T* newlist=new T[sz];
if(newlist==NULL) Error(memoryAllocationError);
//将sz与size中较小的一个赋值给n
int n=(sz <=size)? sz:size;
//将原有数组中前n个元素复制到新数组中
T* srcptr=alist;//原数组alist的首地址
T* destptr=newlist;//新数组newlist的首地址
while(n--)//复制数组元素
*destptr++=*srcptr++;
//删除原数组
delete[] alist;
//使alist指向新数组，并更新size
alist=newlist;size =sz;
}
#endif//ARRAY_CLASS
[解决办法]
~Array(void);
Array <T> & operator =(const Array <T> & rhs);
类里缺少上面两个的声明...
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> &rhs);
////////////////////////////////////////////////////////////
~Array(void);
Array <T> & operator =(const Array <T> & rhs);
//////////////////////////////////////////////////////////////
T &operator[](int i);
operator T*(void) const;
int ListSize(void) const;
void Resize(int sz);
};
[解决办法]
#ifndef ARRAY_CLASS
#define ARRAY_CLASS
#include <iostream.h>
#include <stdlib.h>
#ifndef NULL
const int NULL=0
#endif//NULL
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> &rhs);
T &operator[](int i);
operator T*(void) const;
int ListSize(void) const;
void Resize(int sz);
~Array();
Array <T> & operator =(const Array <T> & rhs);
};
//类成员函数的实现：
template <class T>
void Array <T> ::Error(ErrorType error,int badIndex) const
{
cout < <errorMsg[error];//根据错误类型，输出相应的错误信息
//for indexOutOfRage,print the bad index
if(error==indexOutOfRange)
cout < <badIndex;//如果是下标越界错，输出错误的下标
cout < <endl;
exit(1);
}
//构造函数
template <class T>
Array <T> ::Array(int sz)
{
if(sz <=0)//sz为数组大小（元素个数），若小于0，则输出错误信息
Error(invalidArraySize);
size=sz;//将元素个数赋值给变量size
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)
{
//从对象X取得数组大小，并赋值给当前对象的成员
int n=X.size;
size=n;
//为对象申请内存并进行出错检查
alist=new T[n];
if(alist==NULL)//如果分配内存不成功，输出错误信息
Error(memoryAllocationError);
//从对象X复制数组元素到本对象
T* srcptr=X.alist;
T* destptr=alist;
while(n--)
*destptr++=*srcptr++;
}
//重载 "= "运算符，将对象rhs赋值给本对象，实现对象之间的整体赋值
template <class T>
Array <T> & Array <T> ::operator =(const Array <T> & rhs)
{
int n=rhs.size;//取rhs的数组大小
//如果本对象中数组大小与rhs不同，则删除数组原有内存，然后重新分配
if(size!=n)
{
delet [] alist;//删除数组原有内存
alist=new T[n];//重新分配n个元素的内存
if(alist==NULL)//如果分配内存不成功，输出错误信息
Error(memoryAllocationError);
size=n;//记录本对象的数组大小
}
//从rhs向本对象复制元素
T* destptr=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);
//返回下标为n的数组元素
return alist[n];
}
//重载指针转换操作符，将Array类的对象名转换为T类型的指针，
//指向当前对象中的私有数组。
//因而可以象使用普通数组首地址一样使用Arrary类的对象名
template <class T>
Array <T> ::operator T*(void) const
{
//返回当前对象中私有数组的首地址
return alist;
}
//取当前数组的大小
template <class T>
int Array <T> ::ListSize(void) const
{
return size;}
//将数组大小修改为sz
template <class T>
void Array <T> ::Resize(int sz)
{
//检查是否sz <=0
if(sz <=0)
Error(invalidArraySize);
//如果指定的大小与原有大小一样，什么也不做
if(sz==size) return;
//申请新的数组内存，并测试是否申请成功
T* newlist=new T[sz];
if(newlist==NULL) Error(memoryAllocationError);
//将sz与size中较小的一个赋值给n
int n=(sz <=size)? sz:size;
//将原有数组中前n个元素复制到新数组中
T* srcptr=alist;//原数组alist的首地址
T* destptr=newlist;//新数组newlist的首地址
while(n--)//复制数组元素
*destptr++=*srcptr++;
//删除原数组
delete[] alist;
//使alist指向新数组，并更新size
alist=newlist;size =sz;
}
int main()
{
return 0;
}
#endif//ARRAY_CLASS
楼主编译试试????
没问题....
