Array数组

#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）