#pragma once
#include <iostream>
#include <cstdlib>
#ifndef NULL
const int NULL = 0;
#endif
//错误类型集合,共有三种类型的错误:数组大小错误,内存分配错误,下标越界
enum ErrorType{
invalidArraySize, memoryAllocationError, indexOutOfange
};
//错误信息
static char *errorMsg[] = {
"Invalid array size",
"Memory allocation error",
"Invalid index:"
};
//数组模板
template <typename T>
class Array {
private:
T *alist; //T类型指针,用于存放动态分配的数组首地址
int size; //数组大小(元素个数)
//错误处理函数
void Error(ErrorType error, int badIndex = 0) const;
public:
Array(int sz = 50); //构造函数
Array(const Array<T>& A); //拷贝构造函数
~Array(); //析构函数
//重载“=”,使数组对象可以整体赋值
Array<T>& operator =(const Array<T> &rhs );
//重载“[]”和T*,是Array对象可以起到C++普通数组的作用
T& operator [](int i);
operator T*() const;
int ListSize() const; //取数组大小
void Resize(int sz); //修改数组大小
};
//函数模板 error实现输出错误信息的功能
template <typename T>
void Array<T>::Error(ErrorType error, int badIndex = 0) const {
cout<<errorMsg[error]; //根据错误类型,输出相应的错误信息
if(error == indexOutOfange)
cout<<badIndex;
cout<<endl;
exit(1);
}
//构造函数
template<typename T>
Array<T>::Array(int sz = 50) {
if (sz <= 0){
Error(invalidArraySize);
}
size = sz;
alist = new T[size];
if (alist == NULL){
Error(memoryAllocationError);
}
}
//拷贝构造函数
template<typename T>
Array<T>::Array(const Array<T> & X) {
int n = X.size;
size = n;
alist = new T[size];
if (alist == NULL){
Error(memoryAllocationError);
}
T* srcptr = X.alist;
T* desptr = alist;
while(n--) {
*desptr++ = *srcptr++; //逐个复制数组元素
}
}
//析构函数
template<typename T>
Array<T>::~Array() {
delete []alist;
}
//重载“=”运算符,将对象rhs赋值给本对象,实现对象之间的整体赋值
template<typename T>
Array<T>& Array<T>::operator =(const Array<T> &rhs) {
int n = rhs.size;
//如果本对象中的数组大小与rhs不同,则删除数组原有内存,然后重新分配
if(size != n) {
if(alist != NULL)
delete []alist;
alist = new T[n];
if (alist == NULL){
Error(memoryAllocationError);
}
size = n;
}
T* desptr = alist;
T* srcptr = rhs.alist;
while (n--) {
*desptr++ = *srcptr++;
}
return *this;
}
//重载下标操作符,实现与普通数组一样通过下标访问元素,并且具有越界检查功能
template<typename T>
T& Array<T>::operator [](int i) {
if(i < 0 || i > size -1)
Error(indexOutOfange, i);
return alist[i];
}
//重载指针转换操作符,将Array类的对象名转换为T类型的指针
template<typename T>
Array<T>::operator T *() const {
//返回当前对象中私有数组的首地址
return alist;
}
//取当前数组的大小
template<typename T>
int Array<T>::ListSize() const {
return size;
}
//将数组大小修改为sz
template<typename T>
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;
T* srcptr = alist;
T*desprt = newlist;
while(n--) {
*desprt++ = *srcptr++;
}
delete []alist;
alist = newlist;
size = n;
}
如果要把一个运算符重载为左值,如[],=等,则要讲重载函数的返回值指定为引用,由于引用的实质就是对象的地址,所以通过引用当然可以可变对象的值。
c++中要求赋值表达式可以作为左值,因此“=”重载函数返回值也指定为引用类型。
另外语法规定:=、[]、()、->只能被重载为成员函数。
c++语法规定:重载“类型转换运算符”时,不允许指定返回类型(也不用写void)