封装STL中vector提供MFC中的CArry接口

封装STL中vector提供MFC中的CArry接口

简介：通过封装STL模板库中vector数组，提供MFC中的CArray的相关功能，同时提供vector访问接口

//////////////////////////////////////////////////////////////////////////
//	通过封装STL模板库中vector数组，提供MFC中的CArray的相关功能，同时提供vector访问接口
//////////////////////////////////////////////////////////////////////////
#ifndef		__CARRAYEX_H__
#define		__CARRAYEX_H__

#include 

#if !defined(_WIN32)

#include 

#endif


//数组模板类
template
class CArrayEx
{
public:
	typedef TYPE _Ty;
	typedef CArrayEx _Myt;
	typedef typename std::vector::size_type size_type;
	typedef typename std::vector::const_iterator const_iterator;
	typedef typename std::vector::iterator iterator;
	typedef typename std::vector::const_reverse_iterator const_reverse_iterator;
	typedef typename std::vector::reverse_iterator reverse_iterator;
	typedef typename std::vector::const_reference const_reference;
	typedef typename std::vector::reference reference;

	// 构造函数
	CArrayEx();
	// 析构函数
	~CArrayEx();

	// 获取大小
	INT_PTR GetSize() const;
	// 获取个数
	INT_PTR GetCount() const;
	// 当前数组是否为空
	BOOL IsEmpty() const;
	// 获取数组下标上界，如果数组为空，则为-1
	INT_PTR GetUpperBound() const;
	// 设置数组大小
	void SetSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1);
	// 获取指定位置只读元素
	const TYPE& GetAt(INT_PTR nIndex) const;
	// 获取指定位置元素
	TYPE& GetAt(INT_PTR nIndex);
	// 设置指定位置元素
	void SetAt(INT_PTR nIndex, TYPE const& newElement);
	// 获取指定位置的只读元素
	const TYPE& ElementAt(INT_PTR nIndex) const;
	// 获取指定位置的元素
	TYPE& ElementAt(INT_PTR nIndex);
	// 获取数组的数据首地址，返回只读
	const TYPE* GetData() const;
	// 获取数组的首地址，可写
	TYPE* GetData();
	// 直接获取内部数组
	std::vector* GetArray();

	// 将元素放在指定的位置，若该位置超出数组长度，则自动增长
	void SetAtGrow(INT_PTR nIndex, TYPE const& newElement);
	// 将当前的数据加到数组末尾
	INT_PTR Add(TYPE const& newElement);
	// 拼接两个数组，将指定的数组放到当前数组末尾
	INT_PTR Append(const CArrayEx& src);
	// 数组拷贝，将另一个数组的数据拷贝过来
	void Copy(const CArrayEx& src);

	// 操作符重载
	// 下标操作符重载，返回指定位置只读元素
	const TYPE& operator[](INT_PTR nIndex) const;
	// 下标操作符重载，返回指定位置元素
	TYPE& operator[](INT_PTR nIndex);

	// 在指定位置插入指定个数元素
	void InsertAt(INT_PTR nIndex, TYPE const& newElement, INT_PTR nCount = 1);
	// 删除指定位置元素
	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
	// 在指定位置插入另一个数组
	void InsertAt(INT_PTR nStartIndex, CArrayEx const *pNewArray);

	// 清空额外分配的内存
	void FreeExtra();
	// 删除数组内所有元素
	void RemoveAll();

	//如下函数使CArrayEx仍能按照vector来访问，且未增加任何成员变量，所有函数均内联
	void reserve(size_type _Count)	{ m_vtArray.reserve(_Count);}
	size_type capacity() const		{ return m_vtArray.capacity();}
	iterator begin()				{ return m_vtArray.begin();}
	const_iterator begin() const	{ return m_vtArray.begin();}
	iterator end()					{ return m_vtArray.end();}
	const_iterator end() const		{ return m_vtArray.end();}
	reverse_iterator rbegin()		{ return m_vtArray.rbegin();}
	const_reverse_iterator rbegin() const	{ return m_vtArray.rbegin();}
	reverse_iterator rend()					{ return m_vtArray.rend();}
	const_reverse_iterator rend() const		{ return m_vtArray.rend();}
	void resize(size_type _Newsize)				{ m_vtArray.resize(_Newsize);}
	void resize(size_type _Newsize, TYPE _Val)	{ m_vtArray.resize(_Newsize,_Val);}
	size_type size() const					{ return m_vtArray.size();}
	size_type max_size() const				{ return m_vtArray.max_size();}
	bool empty() const						{ return m_vtArray.empty();}
	const_reference at(size_type _Pos) const{ return m_vtArray.at(_Pos);}
	reference at(size_type _Pos)			{ return m_vtArray.at(_Pos);}
	reference front()						{ return m_vtArray.front();}
	const_reference front() const			{ return m_vtArray.front();}
	reference back()						{ return m_vtArray.back();}
	const_reference back() const			{ return m_vtArray.back();}
	void push_back(const TYPE& _Val)		{ m_vtArray.push_back(_Val);}
	void pop_back()							{ m_vtArray.pop_back();}

	template
	void assign(_Iter _First, _Iter _Last)					{ m_vtArray.template assign<_Iter>(_First, _Last);}
	void assign(size_type _Count, const _Ty& _Val)			{ m_vtArray.assign(_Count, _Val);}
	iterator insert(iterator _Where, const _Ty& _Val)	{ return m_vtArray.insert(_Where, _Val);}
	void insert(iterator _Where, size_type _Count, const _Ty& _Val)	{ m_vtArray.insert(_Where, _Count, _Val);}

	template
	void insert(iterator _Where, _Iter _First, _Iter _Last)	{ m_vtArray.template insert<_Iter>(_Where, _First, _Last);}

	iterator erase(iterator _Where)	{ return m_vtArray.erase(_Where);}
	void clear()							{ m_vtArray.clear();}
	void swap(_Myt& _Right)					{ m_vtArray.swap(_Right.m_vtArray);}
protected:
	std::vector m_vtArray;// 内部数据使用vector

	friend bool operator== (CArrayEx const &lhs, CArrayEx const &rhs);
};
//////////////////////////////////////////////////////////////////////////

// 构造函数
template
CArrayEx::CArrayEx()
{
}

// 析构函数
template
CArrayEx::~CArrayEx()
{
	m_vtArray.clear();
}

// 获取大小
template
inline INT_PTR CArrayEx::GetSize() const
{
	return static_cast(m_vtArray.size());
}

// 获取个数
template
inline INT_PTR CArrayEx::GetCount() const
{
	return static_cast(m_vtArray.size());
}

// 当前数组是否为空
template
inline BOOL CArrayEx::IsEmpty() const
{
	return m_vtArray.empty() ? TRUE : FALSE;
}

// 获取数组下标上界，如果数组为空，则为-1
template
inline INT_PTR CArrayEx::GetUpperBound() const
{
	return static_cast(m_vtArray.size()) - 1;
}

// 设置数组大小,理解vector动态内存增长原理
template
void CArrayEx::SetSize(INT_PTR nNewSize, INT_PTR /*nGrowBy = -1*/)
{
	m_vtArray.resize(nNewSize);
}

// 获取指定位置只读元素
template
const TYPE& CArrayEx::GetAt(INT_PTR nIndex) const
{
	// 当前下标在数组范围内，返回元素
	if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
		return m_vtArray[nIndex];
	throw std::runtime_error("Invalid array index!");
}

// 获取指定位置元素
template
TYPE& CArrayEx::GetAt(INT_PTR nIndex)
{
	// 当前下标在数组范围内，返回元素
	return m_vtArray.at(nIndex);
}

// 设置指定位置元素
template
void CArrayEx::SetAt(INT_PTR nIndex, TYPE const& newElement)
{
	// 当前下标在数组范围内，获取元素并修改值
	if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
		m_vtArray[nIndex] = newElement;
	else
		throw std::runtime_error("Invalid array index!");
}

// 获取指定位置的只读元素
template
const TYPE& CArrayEx::ElementAt(INT_PTR nIndex) const
{
	// 当前下标在数组范围内，返回元素
	if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
		return m_vtArray[nIndex];
	throw std::runtime_error("Invalid array index!");
}

// 获取指定位置的元素
template
TYPE& CArrayEx::ElementAt(INT_PTR nIndex)
{
	// 当前下标在数组范围内，返回元素
	if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
		return m_vtArray[nIndex];
	throw std::runtime_error("Invalid array index!");
}

// 获取数组的数据首地址，返回只读
template
inline const TYPE* CArrayEx::GetData() const
{
	// 数组有内容存在，返回首地址
	if( !m_vtArray.empty() )
	{
		return &m_vtArray[0];
	}
	// 无内容，返回空
	return NULL;
}

// 获取数组的首地址，可写
template
inline TYPE* CArrayEx::GetData()
{
	// 数组有内容存在，返回首地址
	if( !m_vtArray.empty() )
	{
		return &m_vtArray[0];
	}
	// 无内容，返回空
	return NULL;
}

// 直接获取内部数组
template
inline std::vector* CArrayEx::GetArray()
{
	return &m_vtArray;
}

// 将元素放在指定的位置，若该位置超出数组长度，则自动增长
template
void CArrayEx::SetAtGrow(INT_PTR nIndex, TYPE const& newElement)
{
	// 指定的位置不能小于0
	if (nIndex >= 0)
	{
		if (nIndex >= static_cast(m_vtArray.size()))
			m_vtArray.resize(nIndex + 1, newElement);
		else
			m_vtArray[nIndex] = newElement;
	}
}

// 将当前的数据加到数组末尾
template
inline INT_PTR CArrayEx::Add(TYPE const& newElement)
{
	m_vtArray.push_back(newElement);
	return static_cast(m_vtArray.size() - 1);
}

// 拼接两个数组，将指定的数组放到当前数组末尾
template
INT_PTR CArrayEx::Append(const CArrayEx& src)
{
	if (src.m_vtArray.empty())
		return -1;
	INT_PTR iOldIndex = static_cast(m_vtArray.size());
	m_vtArray.insert(m_vtArray.end(), src.m_vtArray.begin(), src.m_vtArray.end());
	return iOldIndex;
}

// 数组拷贝，将另一个数组的数据拷贝过来
template
inline void CArrayEx::Copy(const CArrayEx& src)
{
	m_vtArray.assign(src.m_vtArray.begin(), src.m_vtArray.end());
}

// 下标操作符重载，返回指定位置只读元素
template
inline const TYPE& CArrayEx::operator[](INT_PTR nIndex) const
{
	return m_vtArray[nIndex];
}

// 下标操作符重载，返回指定位置元素
template
inline TYPE& CArrayEx::operator[](INT_PTR nIndex)
{
	return m_vtArray[nIndex];
}

// 在指定位置插入指定个数元素
template
void CArrayEx::InsertAt(INT_PTR nIndex, TYPE const& newElement, INT_PTR nCount /*= 1*/)
{
	//参数检查
	if (nCount <= 0)
		return;

	//插入的位置比当前长度长，插入到指定位置
	if (nIndex >= static_cast(m_vtArray.size()))
	{
		m_vtArray.resize(nIndex + nCount, newElement);
	}
	//插入到中间位置
	else
	{
		m_vtArray.insert(m_vtArray.begin() + nIndex, nCount, newElement);
	}
}

// 删除指定位置元素
template
void CArrayEx::RemoveAt(INT_PTR nIndex, INT_PTR nCount /*= 1*/)
{
	//需要删除的位置必须在数组长度范围内
	if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()) && nCount > 0)
	{
		INT_PTR iLeaveCount = static_cast(m_vtArray.end() - (m_vtArray.begin() + nIndex));
		iLeaveCount = iLeaveCount > nCount ? nCount : iLeaveCount;
		m_vtArray.erase(m_vtArray.begin() + nIndex, m_vtArray.begin() + nIndex + iLeaveCount);
	}
}

// 在指定位置插入另一个数组
template
void CArrayEx::InsertAt(INT_PTR nStartIndex, CArrayEx const *pNewArray)
{
	//需要插入的数组必须存在
	if (!pNewArray)
		return;
	if (pNewArray->m_vtArray.empty())
		return;
	//插入的位置比当前长度长，插入到指定位置
	if (nStartIndex >= static_cast(m_vtArray.size()))
	{
		m_vtArray.resize(nStartIndex + 1);
		m_vtArray.insert(m_vtArray.end(), pNewArray->m_vtArray.begin(), pNewArray->m_vtArray.end());
	}
	//插入到中间位置
	else
	{
		m_vtArray.insert(m_vtArray.begin() + nStartIndex, pNewArray->m_vtArray.begin(), pNewArray->m_vtArray.end());
	}
}

// 清空额外分配的内存
template
inline void CArrayEx::FreeExtra()
{
	return;
}

// 删除数组内所有元素
template
inline void CArrayEx::RemoveAll()
{
	m_vtArray.clear();
}

template
inline bool operator== (CArrayEx const &lhs, CArrayEx const &rhs)
{
	return lhs.m_vtArray == rhs.m_vtArray;
}

//////////////////////////////////////////////////////////////////////////
#endif