数组模板类
数组类的创建主要是为了代替原生数组的使用,数组类可以通过重载数组操作符避免越界访问,提供数组长度信息,提供数组对象之间的复制操作。
- Array.h 接口类
- StaticArray.h 固定大小的数组类,内存在栈上分配
- DynamicArray.h 大小可变的数组类,类似stl中的vector,内存在堆中分配
//Array.h
template <typename T>
class Array
{
protected:
T *m_array;
public:
virtual bool set(int i, const T &e)
{
bool ret = true;
if (i >= 0 && i < length())
{
m_array[i] = e;
}
else
{
ret = false;
}
return ret;
}
virtual bool get(int i, T &e) const
{
bool ret = true;
if (i >= 0 && i < length())
{
e = m_array[i];
}
else
{
ret = false;
}
return ret;
}
T &operator[](int i)
{
if (i >= 0 && i < length())
{
return m_array[i];
}
else
{
THROW_EXCEPTION(IndexOutOfBoundsException, "paramter i is invalid...");
}
}
T operator[](int i) const
{
return const_cast<Array<T> &>(*this)[i];
}
virtual int length() const = 0;
};
//StaticArray.h
template <typename T,int N>
class StaticArray : public Array<T>
{
protected:
T m_space[N];
public:
StaticArray ()
{
this->m_array = m_space;
}
StaticArray (const StaticArray<T,N>& obj)
{
this->m_array = m_space;
for(int i = 0; i < length(); ++i)
{
m_space[i] = obj.m_space[i];
}
}
StaticArray<T,N>& operator = (const StaticArray<T,N>& obj)
{
if(this != &obj)
{
for(int i=0; i < length(); ++i)
{
m_space[i] = obj.m_space[i];
}
}
return *this;
}
int length() const
{
return N;
}
};
//DynamicArray.h
template <typename T>
class DynamicArray :public Array<T>
{
protected:
int m_length;
T* copy(T* array, int len, int newlen)
{
T* ret = new T[newlen];
if(ret != NULL)
{
int size = (len < newlen) ? len : newlen;
for(int i=0; i<size; i++)
{
ret[i] = array[i];
}
}
return ret;
}
void update(T* array, int length)
{
if(array != NULL)
{
T* temp = this->m_array;
this->m_array = array;
this->m_length = length;
delete [] temp;
}
else
{
THROW_EXCEPTION(NoEnoughtMemoryException,"No memory to create DynamicArray object....");
}
}
void init(T* array, int length)
{
if(array != NULL)
{
this->m_array = array;
this->m_length = length;
}
else
{
THROW_EXCEPTION(NoEnoughtMemoryException,"No memory to create DynamicArray object....");
}
}
public:
DynamicArray(int length)
{
init(new T[length],length);
}
DynamicArray(const DynamicArray<T>& obj)
{
init(copy(obj.m_array,obj.m_length,obj.m_length),obj.m_length);
}
DynamicArray<T>& operator = (const DynamicArray<T>& obj)
{
if(this != &obj)
{
update(copy(obj.m_array,obj.m_length,obj.m_length),obj.m_length);
}
return *this;
}
int length() const
{
return m_length;
}
void resize(int length)
{
if(this->m_length != length)
{
update(copy(this->m_array,this->m_length,length), length);
}
}
~DynamicArray()
{
delete[] this->m_array;
}
};