xvector.h

HTTP 搜索代码

/*********************************************************************************************
*	凤凰网络.dragon
*
*	VectorX.h( XLib+ Vector容器 )
*
*	(2006-06-21) 更换内存分配方式为虚拟内存页方式，使用placement new来对对象进行构造，并通过显式析构来防止内存问题。
*	(2006-06-22) 修改掉erase( iStart, iEnd )的一个bug,总是从开头开始调用析构函数，
*
**********************************************************************************************/


#pragma once
#include "xmemory.h"

template < class T, DWORD dwInitMaxEle = 1000 >
class xVector
{
public:
	//class iterator
	//{
	//public:
	//	iterator
	//};
	const DWORD ELEMENTSIZE;
	xVector() : m_pArray( NULL ), m_nMaxSize( 0 ), m_nCurSize( 0 ), ELEMENTSIZE( sizeof( T ) + (MEMORY_ALIGN-(sizeof( T ) & (MEMORY_ALIGN-1))))
	{
		m_pArray = NULL;
		if( !m_vMemory.Create( sizeof( T ) * dwInitMaxEle, 0 ) )
			throw "VectorX虚拟内存分配失败！";
	}

	~xVector()
	{
		for( int i = 0;i < m_nCurSize;i ++ )
		{
			CALL_DEC( &m_pArray[i] );
		}
	}

	void erase( int iPos )
	{
		if( iPos < 0 || iPos >= m_nCurSize )return;
		CALL_DEC( &m_pArray[iPos] );
		if( iPos != --m_nCurSize )
		{
			memmove( m_pArray+iPos, m_pArray+iPos+1, sizeof( T ) * (m_nCurSize - iPos) );
		}
	}

	void erase( int nStart, int nEnd )
	{
		if( nStart < 0 || nStart > nEnd || nEnd > m_nCurSize )return;
		int nEraseSize = nEnd - nStart;
		//	对每个要被删除的元素调用析构
		for( int i = 0;i < nEraseSize;i ++ ){CALL_DEC( &m_pArray[i+nStart] );}
		if( nEnd != m_nCurSize )
		{
			memmove( m_pArray+nStart, m_pArray+nEnd, (m_nCurSize - nEnd) * sizeof( T ) );
		}
		m_nCurSize -= nEraseSize;
	}

	void erase_element( const T & tv )
	{
		int iPos = find( tv );
		erase( iPos );
	}

	int	find( const T & tv )
	{
		for( int i = 0;i < this->m_nCurSize;i ++ )
		{
			if( this->m_pArray[i] == tv )return i;
		}
		return -1;
	}

	void push_back( const T & tv )
	{
		if( full() )
			adjustsize();
		CALL_CON( &m_pArray[m_nCurSize] );
		m_pArray[m_nCurSize++] = tv;
	}

	void push_back_empty( int nSize = 1 )
	{
		insert_empty( size(), nSize );
	}

	void insert_empty( int iPos, int nSize = 1 )
	{
		if( iPos < 0 || nSize < 0 )return;
		if( nSize > m_nMaxSize - m_nCurSize )
		{
			resize( (int)((m_nCurSize + nSize )*1.5f));
		}
		if( iPos > m_nCurSize )
			iPos = m_nCurSize;
		else if( iPos < m_nCurSize )
			memmove( (void*)(m_pArray+iPos+nSize), (void*)(m_pArray+iPos), (m_nCurSize - iPos) * sizeof( T ) );
		for( int i = 0;i < nSize;i ++ )
		{
			CALL_CON( &m_pArray[iPos+i] );
		}
		m_nCurSize += nSize;
	}

	void insert( int iPos, const T & tv )
	{
		if( full() )
			adjustsize();
		if( iPos < 0 )return;

		if( iPos > m_nCurSize )
			iPos = m_nCurSize;
		else if( iPos < m_nCurSize )
			memmove( (void*)(m_pArray+iPos+1), (void*)(m_pArray+iPos), (m_nCurSize - iPos) * sizeof( T ) );
		CALL_CON( &m_pArray[iPos] );
		m_pArray[iPos] = tv;
		m_nCurSize ++;
	}

	void insert( int iPos, int nSize, const T & tv )
	{
		if( iPos < 0 || nSize < 0 )return;
		if( nSize > m_nMaxSize - m_nCurSize )
		{
			resize( (int)((m_nCurSize + nSize )*1.5f));
		}
		if( iPos > m_nCurSize )
			iPos = m_nCurSize;
		else if( iPos < m_nCurSize )
			memmove( (void*)(m_pArray+iPos+nSize), (void*)(m_pArray+iPos), (m_nCurSize - iPos) * sizeof( T ) );
		for( int i = 0;i < nSize;i ++ )
		{
			CALL_CON( &m_pArray[iPos+i] );
			m_pArray[iPos+i] = tv;
		}
		m_nCurSize += nSize;
	}
	
	T & operator[]( int nIndex )
	{
		if( nIndex < 0 || nIndex >= m_nCurSize )throw "";
		return m_pArray[nIndex];
	}

	void clear()
	{
		m_nCurSize = 0;
		resize( 32 );
	}

	int size()
	{
		return m_nCurSize;
	}

	int max_size()
	{
		return m_nMaxSize;
	}

	bool empty()
	{
		return (m_nCurSize == 0);
	}

	bool full()
	{
		return (m_nCurSize == m_nMaxSize);
	}

	void resize( int nSize )
	{
		if( nSize <= 0 )return;
		if( nSize == m_nCurSize )return;

		DWORD dwMemory = nSize * sizeof( T );

		if( dwMemory > m_vMemory.GetMaxSize() )
		{
			//	内存放大，不需要调用任何析构和构造
			if( !m_vMemory.ReCreate( (DWORD)(dwMemory*1.5f), sizeof( T ) * m_nCurSize ) )
				throw "VectorX重新分配内存失败！";
		}
		else
		{
			//	不需要放大，那么就要考虑缩小的情况
			if( nSize < m_nCurSize )
			{
				for( int i = nSize;i < m_nCurSize;i ++ )
				{
					CALL_DEC( &m_pArray[i] );		//	对缩小后挤掉的部分调用析构
				}
			}
		}

		if( !m_vMemory.Resize( dwMemory ) )
			throw "VectorX重新设置大小失败！";

		m_pArray = (T*)m_vMemory.GetBase();
		m_nCurSize = min( nSize, m_nCurSize );
		m_nMaxSize = nSize;
	}
protected:

	void adjustsize()
	{
		if( m_nMaxSize == 0 )
			resize( 32 );
		else
			resize( (int)(m_nMaxSize * 1.5f) );
	}
	xMemory m_vMemory;
	T * m_pArray;
	int m_nMaxSize;
	int m_nCurSize;
};