darray.h

Task: 动态数组模版类 Requirements: 用动态空间实现 代码要规范

#include <iostream.h>

#define SAFEDELETES(p) {if(p){delete []p; p = NULL;}}
#define SAFEDELETE(p) {if(p){delete p; p = NULL;}}
#define TRUE 1
#define FALSE 0

template <class T>
class DArray
{
private:
	int		m_nSize;
	T		*m_pData;
	int		m_nMax;

public:

	DArray();                              //构造函数
	DArray(int size);                      //带参数构造函数
	~DArray();							   //析构函数

	int		Init();							//初始化
	int		SetSize( int size );				//重新设置数组的大小
	int		ClearValues();					// 向量所有元素置0	
    int		Size();							// 获取向量的维数
	T		GetAt( int index );				 //获取第index个元素
	int		SetAt( int index, T value );	//设置第index个元素
	int		Pushback( T value );				//往数组后面追加一个元素
	int     InsertAt( int index, T value );		// 在指标index之前插入一个元素
    int		DeleteAt( int index );				//删除指标index处的元素
    int		OptMemory();                    //释放剩余空间，优化内存
	void	Print();						//打印所有元素
	void	Free();							//释放空间
	T		operator[] ( int index ) const;	//重载操作符[]
   
	
};


template <class T>
DArray<T>::DArray()
{
	Init();
}

template <class T>
DArray<T>::DArray(int size)
{
	Init();
	SetSize(size);
}


template <class T>
DArray<T>::~DArray()
{
	Free();
}


template <class T>
int DArray<T>::Init()
{
	m_nSize = 0;
	m_pData = NULL;
	m_nMax = 0;
	return TRUE;
}


template <class T>
int	DArray<T>::SetSize(int size)
{
	T *pTemp = m_pData;
	m_pData = new T [size];
	if(  m_pData == NULL)
	{
		cout<<" can not alloc new memory! ";
		return FALSE;
	}
	if (m_nSize >= size)
	{
		for (int i=0; i<m_nSize; i++)
		{
			m_pData[i] = pTemp[i];
		}										//保留原数
	} 
	else
	{
		for (int i=0; i<m_nSize; i++)
		{
			m_pData[i] = pTemp[i];				//保留原数
		}
		for( int j=m_nSize; j<size; j++)
		{
			m_pData[j] = 0;						//其余数赋0
		}
	}
	m_nSize = size;
	m_nMax = size;
	return TRUE;
}

template <class T>
int	DArray<T>::Size()
{
	if (m_pData == NULL)
	{
		cout<<"Error!";
		return FALSE;
	}
	return m_nSize;
}

template <class T>
int	DArray<T>::ClearValues()
{
	if (m_nSize == 0)
	{
		cout<<"The array is empty!";
		return FALSE;
	}
	else
	{
		for (int i=0; i<=m_nSize-1; i++)
		{
			m_pData[i] = 0;
		}
		return TRUE;
	}

}

template <class T>
T DArray<T>::GetAt( int index )
{
	if( index < 0 || index >  m_nSize-1 )
	{
		cout << "index is out of range!";
		return FALSE;								// 判断index是否合理
	}

	return  m_pData[index];
}

template <class T>
int	DArray<T>::SetAt( int index, T value )
{
	if( index < 0 || index >  m_nSize-1 )
	{
		cout << "index is out of range!";
		return FALSE;								// 判断index是否合理
	}

	 m_pData[index] = value;
	return TRUE;
}

template <class T>
int DArray<T>::InsertAt(int index, T value)
{
	if( index < 0 || index >  m_nSize )
	{
		cout << "index is out of range!";
		return FALSE; 
	}
	else if (index == m_nSize)
	{
		Pushback(value);							//在数组尾部插入，即Pushback
		return TRUE;
	}
	else
	{
		if (m_nSize < m_nMax)						//空间足够
		{
			for (int i=m_nSize-1; i>=index; i--)	//元素从m_pData[m_nSize-1]到m_pData[index]
			{										//都依次向后移动一位，再将value插到index的位置
				m_pData[i+1] = m_pData[i];
			}
			m_pData[index] = value;
			m_nSize++;
		} 
		else
		{
			T *pTemp =  m_pData;
			if( m_nMax == 0)
			{
				m_nMax = 10;
			}
			else
			{
				m_nMax *= 2;
			}

			m_pData = new T [m_nMax];				//空间不够，则重新分配空间
			
			for( int i=0; i< m_nSize; i++)
			{
				m_pData[i] = pTemp[i];
			}
			for (int j=m_nSize-1; j>=index; j--)
			{
				m_pData[j+1] = m_pData[j];
			}
			m_pData[index] = value;
			m_nSize++;
			SAFEDELETES(pTemp );					//释放空间
			pTemp = NULL;
		}
		return TRUE;
	}

}

template <class T>
int	DArray<T>::Pushback(T value)
{
	if( m_nSize < m_nMax )							//空间足够，则在数组最后加入元素value
	{												//且数组长度加1
		m_pData[m_nSize] = value;
		m_nSize++;
	}
	else
	{
		T *pTemp =  m_pData;
		if( m_nMax == 0)
		{
			m_nMax = 10;
		}
		else
		{
			m_nMax *= 2;
		}

		m_pData = new T [m_nMax];					//空间不够，则重新分配空间

		for( int i=0; i< m_nSize; i++)
		{
			 m_pData[i] = pTemp[i];
		}
		m_pData[  m_nSize ] = value;
		m_nSize++;

		SAFEDELETES(pTemp );
		pTemp = NULL;
	}
	return TRUE;
}

template <class T>
int	DArray<T>::DeleteAt(int index)
{
	if (m_nSize == 0)
	{
		cout<<"Delete an empty array!";		//空数组，无法删除
		return FALSE;
	}
	if( index < 0 || index >  m_nSize-1 )
	{
		cout << "index is out of range!";
		return FALSE; 
	}
	for (int i=index+1; i<=m_nSize-1; i++)			//元素从m_pData[index+1]到m_pData[m_nSize-1]
	{												//都依次向前移动一位，且数组长度减1
		m_pData[i-1] = m_pData[i];
	}
	m_nSize--;
	return TRUE;
}

template <class T>
int	DArray<T>::OptMemory()
{
	if (m_nMax > m_nSize)
	{
		T *pTemp =  m_pData;
		m_pData = new T [m_nSize];
		for (int i=0; i<m_nSize; i++)			//释放剩余空间，优化内存
		{
			m_pData[i] = pTemp[i];
		}
		SAFEDELETES(pTemp );
		pTemp = NULL;
    }
	return TRUE;
}

template <class T>
T DArray<T>::operator[] (int index) const
{
	if (m_nSize == 0)
	{
		cout<<"This is an empty array!";
		return FALSE;
	}
	if( index < 0 || index >  m_nSize-1 )
	{
		cout << "index is out of range!";
		return FALSE; 
	}
	return m_pData[index];
}

template <class T>
void DArray<T>::Free()
{
	SAFEDELETES(m_pData );
}

template<class T>
void DArray<T>::Print()
{
	cout<<"size = "<<m_nSize<<": ";
	for( int i=0; i< m_nSize; i++)
	{
		cout<<m_pData[i]<< " ";
	}
	cout<<endl;
}