Array、StaticArray、DynamicArray

Array类的特点

  Array类的特点：
　　　　-数组类包含数组长度信息，能够发现参数是否越界（扔异常）
　　　　-重载[]，使得可以像原生数组一样使用
　　　　-定义为抽象父类，使用指针完成数组的基本功能
　　　　-指针指向的存储空间的大小与位置由子类提供

数组类的继承结构

Array的实现

Array.h

#ifndef _Array_H_
#define _Array_H_
#include "include/CPlusPlus.h"
#include "include/Object.h"
#include "include/Exception.h"

namespace JYlib
{

template < typename T >
class Array:public Object
{
protected:
	T* m_array;
public:
	virtual bool set(int i,const T& e)
	{
		bool ret = (0 <= i)&&(i < length());
		
		if(ret)
		{
			m_array[i] = e;
		}

		return ret;
	}

	virtual bool get(int i,T& e)const
	{
		bool ret = (0 <= i)&&(i < length());
		
		if(ret)
		{
			e = m_array[i];
		}
		return ret;
	}

	T& operator [](int i)
	{
		if((0 <= i)&&(i < length()))
		{
			return m_array[i];
		}
		else
		{
			THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ...");
		}
	}

	T operator [](int i)const
	{
		return (const_cast<Array<T>&>(this))[i];
	}

	T* array()const
	{
		return m_array;
	}

	virtual int length()const =0;
};

}


#endif

StaticArray的实现

  StaticArray的特点：
　　　　-使用模板参数决定数组大小
　　　　-实现了拷贝构造与赋值操作
　　　　-拷贝原数组与目标数组中空间大小较小的数据，可能会产生截断（多余数据舍弃）

StaticArray.h

#ifndef _StaticArray_H_
#define _StaticArray_H_
#include "Array.h"


namespace JYlib
{

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;

		int length = (N < obj.length() ? N : obj.length);

		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)
		{
			int length = (N < obj.length() ? N : obj.length);
			for(int i=0;i<length;i++)
			{
				m_space[i]=obj.m_space[i];
			}
		}
		return *this;
	}

	int length()const
	{
		return N;
	}
};

}


#endif

DynamicArray的实现

  DynamicArray的特点：
　　　　-动态决定数组的大小
　　　　-实现了拷贝构造与赋值操作
　　　　-拷贝出一个与目标数组一模一样的数组（空间大小与数据），不会发生截断
　　　　-动态重置数组大小时，可能产生截断（多余数据舍弃）

DynamicArray.h

#ifndef _DynamicArray_H_
#define _DynamicArray_H_
#include "include/Array.h"
#include "include/Exception.h"

namespace JYlib
{

template < typename T >
class DynamicArray:public Array<T>
{
protected:
	int m_capacity;//动态内存大小

	//被复制数组,复制长度,新数组大小 返回新数组首地址
	T* copy(T* obj_array,int capacity,int new_capacity)
	{
		T* new_array = new T[new_capacity];

		if(new_array != NULL)
		{
			int length = (new_capacity < capacity ? new_capacity : capacity);

			for(int i = 0;i < length;i++)
			{
				new_array[i] = obj_array[i];
			}
		}
		return new_array;
	}

	//对象新地址,对象新空间大小	（更新对象信息,会释放原对象,符合异常安全性）
	void update(T* obj_array,int capacity)
	{
		if(obj_array != NULL)
		{
			T* temp = this->m_array;
			m_capacity = capacity;
			this->m_array = obj_array;

			delete[] temp;
		}
		else
		{
			THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create DynamicList object ...");
		}
	}

	//对象地址，对象空间大小	（初始化对象信息,不会delete）
	void init(T* obj_array,int capacity)
	{
		if(obj_array != NULL)
		{
			this->m_array = obj_array;
			m_capacity = capacity;
		}
		else
		{
			THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create DynamicList object ...");
		}
	}
public:
	DynamicArray(int capacity = 1)
	{
		init(new T[capacity],capacity);
	}

	DynamicArray(const DynamicArray<T>& obj)
	{
		init(copy(obj.m_array,obj.m_capacity,obj.m_capacity),obj.m_capacity);
	}

	DynamicArray<T>& operator =(const DynamicArray<T>& obj)
	{
		if(this != &obj)
		{
			update(copy(obj.m_array,obj.m_capacity,obj.m_capacity),obj.m_capacity);//复制出一个一模一样的数组

			/*//复制对象内容，原空间大小不变（可能会产生截断）
			int length = (m_capacity < obj.length() ? m_capacity : obj.length());
			for(int i=0;i<length;i++)
			{
				this->m_array[i]=obj.m_array[i];
			}
			*/
		}
		return *this;
	}

	void resize(int new_capacity)
	{
		if(new_capacity != m_capacity)
		{
			update(copy(this->m_array,this->m_capacity,new_capacity),new_capacity);
		}
	}

	int length()const
	{
		return m_capacity;
	}

	~DynamicArray()
	{
		delete[] (this->m_array);
	}
};

}


#endif