线性表的顺序实现

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

class CList

{

public:
CList( const int iDtaSize, void (*FreeFun)( void* ) = NULL );
~CList();

bool Push( void* pDta );
bool InsertDta( int iIndex, void* pDta );

bool DeleteDta( int iIndex, void* pDta );
bool GetElem( int iIndex, void* pDta )const;

bool Clear();

int Length()const;

bool IsListEmpty()const;

  int LocateDta( void* pDta, bool ( *Compare )(void*, void*) )const;

void Show( void (*Print)( void* ) );

static void PrintInt( void* pDta);
static void PrintStr( void* pStr );
static void FreeFunction( void * pDta);

private:
void* m_pDta;
//基地址
int m_iDtaSize;
//元素大小

int m_iAllocSize;
//分配内存大小
int m_iLogSize;
//实际大小

void (*m_pFreeFun)(void*); //元素销毁函数指针
};

CList::CList( const int iDtaSize, void (*FreeFun)( void* )/* = NULL*/ )

{
m_pDta = malloc( 8 * iDtaSize );
m_iLogSize = 0;
m_iAllocSize = 8;
m_iDtaSize = iDtaSize;

m_pFreeFun = FreeFun;

}

CList::~CList()

{
if( m_pDta )
{
if( m_pFreeFun )
{
for( int i = 0; i < m_i
4000
LogSize; ++i )
{
FreeFunction( (char*)m_pDta + i * m_iDtaSize );
}
}
free( m_pDta );
}

}

bool CList::Push( void* pDta )

{
return InsertDta( m_iLogSize, pDta );

}

bool CList::InsertDta( int iIndex, void* pDta )

{
if( iIndex < 0 || iIndex > m_iLogSize || !pDta )
{
return false;
}

if( m_iLogSize >= m_iAllocSize )
{
m_iAllocSize *= 2;
m_pDta = realloc( m_pDta, m_iAllocSize * m_iDtaSize );
}

char* pCur = (char*)m_pDta + iIndex * m_iDtaSize;
memmove( pCur + m_iDtaSize, pCur, ( m_iLogSize - iIndex ) * m_iDtaSize );

memcpy( pCur, pDta, m_iDtaSize );

++m_iLogSize;

return true;

}

bool CList::DeleteDta( int iIndex, void* pDta )

{
if( iIndex < 0 || iIndex > m_iLogSize || !pDta )
{
return false;
}

char* pCur = (char*)m_pDta + iIndex * m_iDtaSize;

memcpy( pDta, pCur, m_iDtaSize );

memmove( pCur, pCur + m_iDtaSize, m_iDtaSize );
--m_iLogSize;
return true;

}

int CList::Length()const

{
return m_iLogSize ;

}

bool CList::IsListEmpty()const

{
return ( m_iLogSize == 0 );

}

bool CList::GetElem( int iIndex, void* pDta )const

{
if( iIndex < 0 || iIndex > m_iLogSize || !pDta )
{
return false;
}

char* pCur = (char*)m_pDta + iIndex * m_iDtaSize;

memcpy( pDta, pCur, m_iDtaSize );

return true;

}

bool CList::Clear()

{
char* pDta = (char*)malloc( m_iDtaSize );
if( !pDta )
{
return false;
}

for( int i = 0; i < m_iLogSize; ++i )
{
GetElem( i, pDta );
if( m_pFreeFun )
{
if( m_pFreeFun)
{
m_pFreeFun(pDta);
}
}
}

if( m_pDta )
{
free( m_pDta );
}

m_pDta = malloc( 8 * m_iDtaSize );
m_iLogSize = 0;
m_iAllocSize = 8;

return true;

}

int CList::LocateDta( void* pDta, bool ( *Compare )(void*, void*) )const

{
char* pBuf = (char*)malloc( m_iDtaSize );
if( !pBuf )
{
return -1;
}

for( int i = 0; i < m_iLogSize; ++i )
{
GetElem( i, pBuf );
if( Compare( pDta, pBuf ) )
{
if( pBuf )
{
free( pBuf );
}
return i;
}
}

if( pBuf )
{
free( pBuf );
}

return -1;

}

void CList::Show( void (*Print)( void* ) )

{
for( int i = 0; i < m_iLogSize; ++i )
{
char* pChar = (char*)m_pDta + i * m_iDtaSize;
Print( pChar );
}

}

 void CList::PrintInt( void* pDta)

{
int* pIntDta = (int*)pDta;
if( !pIntDta )
{
return;
}
printf("%d\n", *pIntDta );

}

 void CList::PrintStr( void* pStr )

{
char* pDta = *(char**)pStr;
if( !pDta )
{
return;
}

printf( "%s\n", pDta );

}

void CList::FreeFunction( void * pDta)

{
char* pFree = *(char**)pDta;
if( pFree )
{
free( pFree );
}

}

int main(int argc, char* argv[])

{

CList lst( sizeof(char*), FreeStrFun);

char szArr[4];
int iNum = 1000;
for( int i = 0; i < iNum; ++i)
{
sprintf( szArr, "%d", i);

  char* pDta = strdup( szArr );
lst.Push( &pDta );
}

for( i = 0; i < 500; ++i )
{
char* pDta = (char*)malloc( 10 );
lst.Delete(0, &pDta);
}

const int iLen = lst.Length();
for( i = 0; i < iLen; ++i )
{
char* pDta = (char*)malloc( 10 );
if( !lst.GetElem( i, &pDta ) )
{
continue;
}

printf( "%s\t", pDta );
}

return 0;

}