memlist.cpp

中文编码转换

#include "stdafx.h"
#include "windows.h"
#include "malloc.h"
#include "memlist.h"
#include "stdlib.h"
#include "search.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


void CMemList::init (int _iSize, int _iIncSize)
{
	memFree ();

	if (_iSize > 0)
		m_lBlockSize = _iSize;
	else
	m_lBlockSize = 0;

	m_lMemSize   = 0;
	m_tpHead     = NULL;
	m_lTotalNum  = 0;

	if (_iIncSize < 1)	m_iIncSize = 1;
	else				m_iIncSize   = _iIncSize;

	//predel = NULL ;
}

void CMemList::inittest(int _iSize, int _iIncSize/* =100 */)
{
	if (_iSize > 0)
		m_lBlockSize = _iSize;
	else
	m_lBlockSize = 0;

	m_lMemSize   = 0;
	m_tpHead     = NULL;
	m_lTotalNum  = 0;

	if (_iIncSize < 1)	m_iIncSize = 1;
	else				m_iIncSize   = _iIncSize;
}


CMemList::CMemList (int _iSize, int _iIncSize)
{
	if (_iSize > 0)
		m_lBlockSize = _iSize;
	else
	m_lBlockSize = 0;
	m_lMemSize  = 0;
	m_tpHead    = NULL;
	m_lTotalNum = 0;

	if (_iIncSize < 1)	m_iIncSize = 1;
	else				m_iIncSize = _iIncSize;

	//predel = NULL;
}

CMemList::CMemList ()
{
	m_lBlockSize = 0;
	m_lMemSize = 0;
	m_tpHead = NULL;
	m_lTotalNum = 0;
	m_iIncSize   = 1;

	//predel = NULL;
}
CMemList::~CMemList ()
{
	memFree ();
}

//void CMemList::addPreDelFunc ( void (*_predel)(void *))
//{
//	predel = _predel;
//}

void* CMemList::operator[] (int _idx)
{
	return getData (_idx);
}

// KCKIM 2002.03.12 {
void CMemList::operator= (CMemList& oSrc)
{
	memFree ();

	int iCopySize = oSrc.m_lTotalNum * oSrc.m_lBlockSize;
	if (iCopySize <= 0)
		return;

	this->m_tpHead = malloc (iCopySize);
	if (m_tpHead == NULL)
		return;

	this->m_iIncSize   = oSrc.m_iIncSize;
	this->m_lBlockSize = oSrc.m_lBlockSize;
	this->m_lMemSize   = oSrc.m_lMemSize ;
	this->m_lTotalNum  = oSrc.m_lTotalNum;

	memcpy (this->m_tpHead, oSrc.m_tpHead, iCopySize);
}
// KCKIM 2002.03.12 }

BOOL CMemList::operator != ( CMemList& oSrc )
{
	if( (this->m_iIncSize == oSrc.m_iIncSize) && (this->m_lBlockSize == oSrc.m_lBlockSize)
		&& (this->m_lMemSize == oSrc.m_lMemSize) && (this->m_lTotalNum == oSrc.m_lTotalNum)
		&& (this->m_tpHead == oSrc.m_tpHead) )
		return FALSE;
	else
		return TRUE;
}


void * CMemList::memAlloc ()
{
	if (m_lMemSize <= m_lTotalNum)
	{
		m_lMemSize += m_iIncSize;
		if(m_tpHead == NULL)
		{
			m_tpHead = malloc (m_lBlockSize*m_lMemSize);
			if (m_tpHead == NULL)
				return NULL;
		}
		else
		{
			m_tpHead = realloc (m_tpHead,m_lBlockSize*m_lMemSize);
			if (m_tpHead == NULL)
				return NULL;
		}
	}

	return  (void*)((char*)m_tpHead + m_lBlockSize*m_lTotalNum);
}
void CMemList::memFree ()
{
	if (m_tpHead)
		free(m_tpHead);
	m_tpHead = NULL;
	m_lMemSize = 0;
	m_lTotalNum = 0;
}
void * CMemList::getHead ()
{
	return m_tpHead;
}
long CMemList::count()
{
	return m_lTotalNum;
}

void * CMemList::add (void * tpData)
{
	void * tpNew = memAlloc();
	if (tpNew == NULL)
		return NULL;

	memcpy (tpNew, tpData, m_lBlockSize);
	m_lTotalNum++;

	return tpNew;
}

void * CMemList::add (void * tpData, int _iNth = -1)
{
	if (tpData == NULL)
		return NULL;

	if (_iNth < 0)
		_iNth = m_lTotalNum;

	void * tpNew = memAlloc();
	if (tpNew == NULL)
		return NULL;
	m_lTotalNum++;

	if ( m_lTotalNum-1 == _iNth) // 盖第俊 眠啊.
	{
		memcpy (tpNew, tpData, m_lBlockSize);
		return tpNew;
	}

	for (int nn=m_lTotalNum-1; nn>_iNth; nn--)
		memcpy ((char*)m_tpHead+(m_lBlockSize*(nn)), (char*)m_tpHead+m_lBlockSize*(nn-1), m_lBlockSize);

	memcpy ((char*)m_tpHead+(m_lBlockSize*_iNth), tpData, m_lBlockSize);

	return getData (_iNth);
}


void * CMemList::getData (int _iNth) // zero base
{
	if (_iNth < 0 || _iNth>= m_lTotalNum)
		return NULL;

	return (void*)((char*)m_tpHead+ m_lBlockSize*_iNth);
}


int  CMemList::del (int _iNth)  // zero base
{
	if (_iNth < 0 || _iNth>= m_lTotalNum)
		return FALSE;

	memcpy ((char*)m_tpHead+(m_lBlockSize*_iNth),
			(char*)m_tpHead+(m_lBlockSize*(_iNth+1)),
			m_lBlockSize*(m_lTotalNum-1-_iNth));

	m_lTotalNum--;

	return TRUE;

}

void CMemList::delAll ()
{
	memFree ();
}

int	CMemList::getBlockSize ()
{
	return m_lBlockSize;
}

void CMemList::qSort ( int (* SortFunc) (const void* ele1, const void* ele2))
{
	qsort ( m_tpHead,  m_lTotalNum, m_lBlockSize, SortFunc );
}
void * CMemList::bFind ( const void *key, const void *base, unsigned int num, unsigned int width, int (__cdecl *compare)(const void *elem1, const void *elem2) )
{
	return bsearch( key, base, num, width, compare);
}
void * CMemList::bFind ( const void *key, int (__cdecl *compare)(const void *elem1, const void *elem2) )
{
	return bsearch( key, m_tpHead, m_lTotalNum, m_lBlockSize, compare);
}

void* CMemList::qFind (const void* _pKey, int (*FindSortFunc)(const void*, const void*), int _iFindOption /*=0*/, int* _ipNearNth /*=NULL*/)
{
	void* tpHead = getHead ();
	if (tpHead == NULL)
		return NULL;

	int iMaxCnt = count ();
	if (iMaxCnt<1)
		return NULL;

	int iS = 0;
	int iE = iMaxCnt-1;
	int iM = (iE+iS)/2;

	int iNearMin = 0;
	int iNearMax = iMaxCnt-1;

	void * tpCur = NULL;
	while ( 1 )
	{

		tpCur = getData (iM);
		int iRes = FindSortFunc (_pKey, tpCur );
		if ( iRes == 0)
		{
			if (_ipNearNth)
				*_ipNearNth = iM;
			return tpCur;
		}

		if (iRes > 0)
		{
			iNearMin = iM;
			iS=iM+1;
		}
		else
		{
			iNearMax = iM;
			iE = iM-1;
		}
		iM = (iS+iE)/2;

		if (iE<iS)
		{
			break;
		}
	}

	if (_iFindOption < 0)
	{
		if(_ipNearNth) 
			*_ipNearNth = iNearMin;
		return getData (iNearMin);
	}
	else if (_iFindOption > 0)
	{
		if(_ipNearNth) 
			*_ipNearNth = iNearMax;
		return getData (iNearMax);
	}

	return NULL;
}



//===============================================================================
//===============================================================================
// 皋葛府 钮 备泅.
CMemQ::CMemQ() // default绰 long蔼捞 100俺肺 悸泼凳 
{
	m_cpHead = NULL;
	initVar ();
	allocStack(sizeof(long), 100);
}
CMemQ::CMemQ(int _iUnitSize, int _iNum)
{
	m_cpHead = NULL;
	initVar ();
	allocStack (_iUnitSize, _iNum);
}
CMemQ::~CMemQ()
{
	freeStack();
	initVar ();
}

// 捞 窃荐绰 皋葛府 庆歹(m_cpHead)甫 力寇茄 函荐甸阑 檬扁拳 茄促.
void CMemQ::initVar ()
{
	m_iUnitSize	= 0;
	m_iMax		= 0;
	m_iCurPos	= 0;
	m_iBasePos	= 0;
	m_iCount	= 0;
}

char* CMemQ::allocStack(int _iUnitSize, int _iNum)
{
	if (m_cpHead)				delete [] m_cpHead;
	if (_iUnitSize*_iNum< 0)	return NULL;

	m_cpHead = new char[_iUnitSize*_iNum +1];
	initVar ();

	m_iUnitSize = _iUnitSize;
	m_iMax = _iNum;

	return m_cpHead;
}
void CMemQ::freeStack()
{
	if ( m_cpHead)
		delete[] m_cpHead;
	m_cpHead = NULL;
}

int CMemQ::unitSize()
{
	return m_iUnitSize;
}
int CMemQ::num()
{
	return m_iCount;
}

// getData绰 蔼阑 昏力矫虐瘤 臼绊 蔼阑 掘绢柯促.
void* CMemQ::getData(int _iNth)
{
	return (m_cpHead + m_iUnitSize*_iNth);
}

// 钮狼 场俊 单捞磐甫 敬促.
void* CMemQ::put (void* _pUnit)
{
	if (m_cpHead == NULL)
		return NULL;

	// 钮啊 菜蛮版快 歹捞惑 甸绢哎 蜡粗傍埃捞 绝促.
	//{{
//	if (m_iCurPos == m_iBasePos-1)
//		return NULL;
	if (m_iCount == m_iMax)
		return NULL;
	//}}

	memcpy (m_cpHead + m_iCurPos*m_iUnitSize, _pUnit, sizeof(m_iUnitSize));
	
	int iPos = m_iCurPos;
	m_iCurPos++;
	m_iCount++;
	if (m_iCurPos >= m_iMax)
		m_iCurPos = 0;

	return (m_cpHead+ iPos*m_iUnitSize);
}

void* CMemQ::get()
{
	if (m_cpHead == NULL)
		return NULL;

	// 钮啊 胖 厚绢 酒公巴档 绝绰 版快. 
	// {{
	if (m_iCount == 0)
		return NULL;
//	if (m_iBasePos == m_iCurPos)
//		return NULL;
	// }}

	int iBase = m_iBasePos;
	m_iBasePos++;
	if (m_iBasePos >= m_iMax)
		m_iBasePos = 0;

	m_iCount--;
	return (m_cpHead + iBase*m_iUnitSize);
}




//===============================================================================
//===============================================================================


CMemListArray ::CMemListArray ()
{
	oArr.init (sizeof(TArrayPointList));
}

void * CMemListArray ::add (void * _tpData)
{
	TArrayPointList tUnit;
	tUnit.vpPtr = _tpData;
	void* ptRes = oArr.add ((void*)(&tUnit),-1);
	return ptRes;
}
void * CMemListArray ::	add (void * _tpData, int _iNth)
{
	TArrayPointList tUnit;
	tUnit.vpPtr = _tpData;
	return oArr.add (&tUnit, _iNth);
}
long  CMemListArray ::count()
{
	return oArr.count ();
}
void* CMemListArray ::getData (int _iNth)
{
	TArrayPointList* tpCur = (TArrayPointList* )oArr.getData (_iNth);
	if (tpCur)
	{
		return tpCur->vpPtr;
	}

	return NULL;
}
void* CMemListArray ::getHead ()
{
	return (void*)oArr.getHead (); 
}
int  CMemListArray ::del (int _iNth)
{
	return oArr.del (_iNth);
}
void CMemListArray ::delAll ()
{
	oArr.delAll ();
}
int  CMemListArray ::getBlockSize ()
{
	return oArr.getBlockSize ();
}
void CMemListArray ::qSort ( int (* SortFunc) (const void* ele1, const void* ele2))
{
	oArr.qSort ( SortFunc );
}