array1d.h

这是一个简单的C++数组类程序,因为我学习过程中经常用到数组类,所以感到一定有很多人需要,特上传.

#ifndef ARRAY1D_H
#define ARRAY1D_h

# include <iostream.h>

template<class T>
class Array1D
{
public:
	//一唯数组构造函数，参数为元素个数，缺省为十个元素
	Array1D(int MaxSize=10)
	{
		m_nMaxSize=MaxSize;
		m_tElement=new T[m_nMaxSize];
		for(int i=0;i<m_nMaxSize;i++)
		{
			m_tElement[i]=0;
		}
	}
	//一唯数组构造函数，由同类型数组构造而来
	Array1D(const Array1D<T>& NewArr)
	{
		m_nMaxSize=NewArr.GetSize();
		m_tElement=new T[m_nMaxSize];
		for(int i=0;i<m_nMaxSize;i++)
		{
			m_tElement[i]=NewArr[i];
		}
	}
	//析构函数
	~Array1D()
	{
		delete[] m_tElement;
	}

	//重载[]操作符，使类能象数组一样操作
	T& operator[](int i) const;

	//重载=操作符，实现数组之间的拷贝
	Array1D<T>& operator=(const Array1D<T>& NewArr) ;

	//输出数组，主要为调试用
	void CoutArray() const;	

	//改变数组的大小
	void Resize(int nNewSize,bool bIsPreserveValue);

	//得到数组的大小
	int GetSize() const
	{
		return m_nMaxSize;
	};

	//得到数组中某元素的拷贝
	T at(int index) const;

	//在数组末尾添加一个元素
	void  Append(const T& t);

	//使数组以升序排列
	void  Sort();

	//使数组以降序排列
	void  SortReverse(); 
private:
	//数组的长度
	int m_nMaxSize;

	//数组首地址的指针
	T*  m_tElement;
};

//重载[]操作符，使类能象数组一样操作
template<class T>
T& Array1D<T>::operator[](int i) const
{
	return m_tElement[i];
}

//得到以i为下标的数组元素的拷贝，当参数越界时指向最近的合法元素
template<class T>
T  Array1D<T>::at(int index) const
{
	if( index<0 )
		return m_tElement[0];
	else if(index>m_nMaxSize-1)
		return m_tElement[m_nMaxSize-1];
	else
		return m_tElement[index];
}

//在数组末尾添加一个元素，数组大小也随之扩充
template<class T>
void  Array1D<T>::Append(const T& t) 
{
	m_nMaxSize++;
	Resize(m_nMaxSize,true);	
	m_tElement[m_nMaxSize-1]=t;
}

//使数组以升序排列
template<class T>
void  Array1D<T>::Sort() 
{
	int i,j;
	
	for(j=1;j<m_nMaxSize;j++)
	{
		for(i=0;i<m_nMaxSize-j;i++)
		{
			if(m_tElement[i]>=m_tElement[i+1] )
			{
				T tmp;
				tmp=m_tElement[i+1];
				m_tElement[i+1]=m_tElement[i];
				m_tElement[i]=tmp;
			}
		}
	}
}

//使数组以降序排列
template<class T>
void  Array1D<T>::SortReverse() 
{
	int i,j;
	
	for(j=1;j<m_nMaxSize;j++)
	{
		for(i=0;i<m_nMaxSize-j;i++)
		{
			if(m_tElement[i]<=m_tElement[i+1] )
			{
				T tmp;
				tmp=m_tElement[i+1];
				m_tElement[i+1]=m_tElement[i];
				m_tElement[i]=tmp;
			}
		}
	}
}

//依次输出数组元素，供调试用
template<class T>
void  Array1D<T>::CoutArray() const
{
	cout<<"\nCout Array1D\n";
	for(int i=0;i<m_nMaxSize;i++)
	{		
		cout<<m_tElement[i]<<"\t";

		if ((i+1 % 10) ==0)
			cout<<"\n";
	}
}

//重新设置数组大小，当参数bIsPreserveValue为真时保持原值，为假时全部置零
template<class T>
void Array1D<T>::Resize(int nNewSize,bool bIsPreserveValue)
{
	T*  Elementtmp=new T[nNewSize];
	int i;

	for(i=0;i<nNewSize;i++)
	{
		Elementtmp[i]=0;
	}

	if(bIsPreserveValue)
	{
		for(i=0;i<((nNewSize>m_nMaxSize)?m_nMaxSize:nNewSize);i++)
		{
			Elementtmp[i]=m_tElement[i];
		}
	}

	delete[] m_tElement;
	m_tElement=Elementtmp;
	m_nMaxSize=nNewSize;
}

//重载=操作符，实现数组之间的拷贝
template<class T>
Array1D<T>& Array1D<T>::operator=(const Array1D<T>& NewArr) 
{
	if(this!=&NewArr)
	{
		m_nMaxSize=NewArr.GetSize();
		delete[] m_tElement;
		m_tElement=new T[m_nMaxSize];

		for(int i=0;i<m_nMaxSize;i++)
		{
			m_tElement[i]=NewArr[i];	
		}
	}

	return *this;
}



#endif