arraylist.h

C# ArrayList C++模仿版

			i=0;
		}
		(*pf->length)+=(*pc->length);
		(*pf->size)+=1;
		pf->data[i]=(void*)pc;
		*pc->parent=pf;
		i++;
		l+=*pc->length;
		if(pcl!=NULL)
			*pcl=pc;
		pc=*pc->next;
	}
	pn=*pf->next;
	if(pfl!=NULL)
		*pfl=pn;
	while(pn!=NULL){
		pf=*pn->next;
		MT_Delete_Node(pn);
		pn=pf;
	}
	if(pch==NULL){
		MT_Delete_Node(pfh);
		pfh=NULL;
	}
	MT_OBJ o;
	o.length=l;
	o.pParent=pfh;
	o.pChild=pch;
	return o;
}

inline void MT_Ist(PMT_OBJ po,unsigned long i,void** ptrarray,unsigned long l)
{
	i--;
	if(ptrarray==NULL||l==0||po==NULL)
		return;
	if(po->length<=i&&i!=-1){
		if(po->length!=0)
			return;
		else
			if(i>=0)
				return;
	}
	PNODE_MT_ pfh=NULL,pfl=NULL,pch=NULL,pcl=NULL,pi=NULL;
	unsigned long k;
	//create
	if(po->length==0&&po->pParent==NULL&&po->pChild==NULL){
		pch=MT_Create_List(ptrarray,l,&pcl);
		*po=MT_Refresh_OBJ(NULL,pch,&pfl,&pcl);
		return;
	}
	//insert
	if(i==-1){
		pi=po->pChild;
		k=-1;
	}
	else{
		if((pi=MT_Get_Node(po,i,k))==NULL){
			return;
		}
	}
	MT_Insert_List(pi,k,ptrarray,l);
	*po=MT_Refresh_OBJ(po->pParent,po->pChild,&pfl,&pcl);
}

inline void MT_Ist(PMT_OBJ po,unsigned long i,PMT_OBJ poi)
{
	if(po==NULL||poi==NULL||poi->length==0)
		return;
	if(po->length<i){
		return;
	}
	PNODE_MT_ pfh=NULL,pfl=NULL,pch=NULL,pcl=NULL,pi=NULL;
	unsigned long k;
	if(po->length==0&&po->pParent==NULL&&po->pChild==NULL){
		pch=MT_Create_Node();
		MT_Insert_List(pch,0,poi->pChild);
		*po=MT_Refresh_OBJ(NULL,pch,&pfl,&pcl);
		return;
	}
	if(i==po->length){
		if((pi=MT_Get_Node(po,i-1,k))==NULL)
			return;
		if(*pi->length>=NODE_SIZE){
			*pi->next=MT_Create_Node();
			pi=*pi->next;
			k=0;
		}
		else
			k++;
	}
	else{
		if((pi=MT_Get_Node(po,i,k))==NULL)
			return;
	}
	MT_Insert_List(pi,k,poi->pChild);
	*po=MT_Refresh_OBJ(po->pParent,po->pChild,&pfl,&pcl);
}

inline void MT_Del(PMT_OBJ po,unsigned long i,unsigned long l)
{
	if(l==0||po==NULL)
		return;
	if(po->length<=i)
		return;
	PNODE_MT_ pfh=NULL,pfl=NULL,pch=NULL,pcl=NULL,pi=NULL;
	unsigned long k=0;
	if((pi=MT_Get_Node(po,i,k))==NULL)
		return;
	try{
		MT_Delete_List(pi,k,l);
		*po=MT_Refresh_OBJ(po->pParent,po->pChild,&pfl,&pcl);
	}
	catch(...){
		return;
	}
}

inline void MT_Clr(PMT_OBJ po)
{
	if(po==NULL)
		return;
	if(po->length==NULL||po->pParent==NULL||po->length==0)
		return;
	PNODE_MT_ pt=po->pChild,pb=NULL;
	while(pt!=NULL){
		pb=*pt->next;
		MT_Delete_Node(pt);
		pt=pb;
	}
	pt=po->pParent;
	while(pt!=NULL){
		pb=*pt->next;
		MT_Delete_Node(pt);
		pt=pb;
	}
	po->pChild=NULL;
	po->pParent=NULL;
	po->length=0;
}

inline MT_OBJ MT_Get(PMT_OBJ po,unsigned long i,unsigned long l)
{
	MT_OBJ o={0};
	if(po==NULL)
		return o;
	if(po->length<=i||l==0)
		return o;
	PNODE_MT_ pn,pt,ph;
	unsigned long k,len;
	pn=MT_Get_Node(po,i,k);
	pt=MT_Create_Node();
	ph=pt;
	if(l<(*pn->length)-k){
		*pt->length=l;
		*pt->size=l;
		memcpy(pt->data,&pn->data[k],l*sizeof(void*));
		o=MT_Refresh_OBJ(NULL,pt);
		return o;
	}
	len=(*pn->length)-k;
	memcpy(pt->data,&pn->data[k],len*sizeof(void*));
	*pt->length=len;
	*pt->size=len;
	*pt->next=MT_Create_Node();
	pt=*pt->next;
	l-=len;
	len=0;
	pn=*pn->next;
	while(pn!=NULL){
		len+=(*pn->length);
		if(len>=l){
			l-=len-(*pn->length);
			memcpy(pt->data,pn->data,l*sizeof(void*));
			*pt->length=l;
			*pt->size=l;
			o=MT_Refresh_OBJ(NULL,ph);
			return o;
		}
		memcpy(pt->data,pn->data,(*pn->length)*sizeof(void*));
		*pt->length=(*pn->length);
		*pt->size=(*pn->length);
		*pt->next=MT_Create_Node();
		pt=*pt->next;
		pn=*pn->next;
	}
	return o;
}

inline void MT_Ref(PMT_OBJ po)
{
	if(po==NULL)
		return;
	if(po->length==NULL||po->pParent==NULL)
		return;
	MT_Refresh_List(po->pChild);
	*po=MT_Refresh_OBJ(po->pParent,po->pChild);
}

///////////////////////////////////////////////////////////////////////////////////
//Template implement:

template<class Type>
inline void MT_CopyType(PMT_OBJ po)
{
	unsigned long i,j,fl,cl;
	PNODE_MT_ pf=NULL,pc=NULL;
	Type *pd=NULL,*pt=NULL;
	pf=po->pParent;
	while(pf!=NULL){
		fl=*pf->size;
		for(i=0;i<fl;i++){
			pc=(PNODE_MT_)pf->data[i];
			cl=*pc->size;
			for(j=0;j<cl;j++){
				pd=(Type*)pc->data[j];
				pt=new Type;
				*pt=*pd;
				pc->data[j]=(void*)pt;
			}
		}
		pf=*pf->next;
	}
}

template<class Type>
inline void MT_CopyType(void** pointer_array,unsigned long l)
{
	Type *pd=NULL,*pt=NULL;
	unsigned long i;
	for(i=0;i<l;i++){
		pt=new Type;
		pd=(Type*)pointer_array[i];
		*pt=*pd;
		pointer_array[i]=(void*)pt;
	}
}

template<class Type>
inline void MT_DelType(PMT_OBJ po)
{
	unsigned long i,j,fl,cl;
	PNODE_MT_ pf=NULL,pc=NULL;
	Type *pd=NULL,*pt=NULL;
	pf=po->pParent;
	while(pf!=NULL){
		fl=*pf->size;
		for(i=0;i<fl;i++){
			pc=(PNODE_MT_)pf->data[i];
			cl=*pc->size;
			for(j=0;j<cl;j++){
				pd=(Type*)pc->data[j];
				delete pd;
				pc->data[j]=NULL;
			}
		}
		pf=*pf->next;
	}
}

template<class Type>
ArrayList<Type>::ArrayList()
{
	MT_Init();
	try{ 
		free(m_pData);
	}
	catch(...){
	}
	m_pData=malloc(sizeof(MT_OBJ));
	memset(m_pData,0,sizeof(MT_OBJ));
};

template<class Type>
ArrayList<Type>::~ArrayList()
{
	Clear();
	free(m_pData);
};

template<class Type>
void* ArrayList<Type>::Get_Inside_Data()
{
	return m_pData;
};

template<class Type>
void ArrayList<Type>::Clone(ArrayList<Type>& al)
{
	PMT_OBJ po=(PMT_OBJ)al.Get_Inside_Data();
	Clear();
	PMT_OBJ pr=(PMT_OBJ)m_pData;
	*pr=MT_Get(po,0,po->length);
	MT_CopyType<Type>(pr);
};

template<class Type>
unsigned long ArrayList<Type>::GetLength()
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	return po->length;
};

template<class Type>
ArrayList<Type> ArrayList<Type>::GetSubList(unsigned long position,unsigned long length)
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(position>lb)
		position=lb;
	if(length+position>lb)
		length=lb-position;
	ArrayList<Type> al;
	MT_OBJ mo=MT_Get(po,position,length);
	MT_CopyType<Type>(&mo);
	memcpy(al.Get_Inside_Data(),&mo,sizeof(mo));
	return al;
};

template<class Type>
unsigned long ArrayList<Type>::GetSubList(unsigned long position,unsigned long length,Type** pointer_array,unsigned long array_length)
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(position>lb)
		position=lb;
	if(array_length<length)
		length=array_length;
	if(position+length>lb)
		length=lb-position;
	try{
		MT_Get(po,(void**)pointer_array,position,length);
		MT_CopyType<Type>((void**)pointer_array,length);
	}
	catch(...){
		return AL_FAILED;
	}
	return length;
};

template<class Type>
unsigned long ArrayList<Type>::Insert(unsigned long position,unsigned long length,Type** pointer_array,unsigned long array_length)
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(position>lb)
		position=lb;
	if(array_length<length)
		length=array_length;
	void** pa=(void**)malloc(sizeof(void*)*length);
	try{
		memcpy(pa,pointer_array,sizeof(void*)*length);
		MT_CopyType<Type>((void**)pa,length);
		MT_Ist(po,position,(void**)pa,length);
	}
	catch(...){
		free(pa);
		return AL_FAILED;
	}
	free(pa);
	return po->length-lb;
};

template<class Type>
unsigned long ArrayList<Type>::Insert(unsigned long position,ArrayList<Type>& al)
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(position>lb)
		position=lb;
	PMT_OBJ pi=(PMT_OBJ)al.m_pData;
	PMT_OBJ pt=(PMT_OBJ)malloc(sizeof(MT_OBJ));
	try{
		*pt=MT_Get(pi,0,pi->length);
		MT_CopyType<Type>(pt);
		MT_Ist(po,position,pt);
	}
	catch(...){
		free(pt);
		return AL_FAILED;
	}
	free(pt);
	return po->length-lb;
};

template<class Type>
unsigned long ArrayList<Type>::Remove(unsigned long position,unsigned long length)
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(position>lb)
		position=lb;
	if(position+length>lb)
		length=lb-position;
	PMT_OBJ pt=(PMT_OBJ)malloc(sizeof(MT_OBJ));
	try{
		*pt=MT_Get(po,position,length);
		MT_DelType<Type>(pt);
		MT_Clr(pt);
		MT_Del(po,position,length);
	}
	catch(...){
		free(pt);
		return AL_FAILED;
	}
	free(pt);
	return lb-po->length;
};

template<class Type>
void ArrayList<Type>::Clear()
{
	try{
		MT_DelType<Type>((PMT_OBJ)m_pData);
		MT_Clr((PMT_OBJ)m_pData);
	}
	catch(...){
	}
	memset(m_pData,0,sizeof(MT_OBJ));
};

template<class Type>
Type& ArrayList<Type>::operator[](unsigned long i)
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(i>=lb)
		i=lb-1;
	Type* p=NULL;
	try{
		p=(Type*)MT_Get(po,i);
	}
	catch(...){
	}
	return *p;
};

template<class Type>
void ArrayList<Type>::Refresh()
{
	PMT_OBJ po=(PMT_OBJ)m_pData;
	unsigned long lb=po->length;
	if(lb==0)
		return;
	try{
		MT_Ref(po);
	}
	catch(...){
	}
	return;
}

//////////////////////////////////////////////////
//Windows Test samples
/*
#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<Psapi.h>
#pragma comment(lib,"Psapi.lib")

ArrayList<unsigned long>* makeAL()
{
	ArrayList<unsigned long> *pal=new ArrayList<unsigned long>;
	unsigned long *k=(unsigned long*)malloc(sizeof(unsigned long)*0x3000);
	unsigned long **p=(unsigned long**)malloc(sizeof(unsigned long*)*0x3000);
	unsigned long i;
	for(i=0;i<0x3000;i++){
		k[i]=i;
		p[i]=&k[i];
	}
	pal->Insert(0,0x3000,p,0x3000);
	free(p);
	free(k);
	return pal;
}

void main(){
	ArrayList<unsigned long> al1,*pal1,al2,*pal2;
	pal1=makeAL();
	HANDLE hProc=GetModuleHandle(NULL);
	PROCESS_MEMORY_COUNTERS pmc={0};
	DWORD sz=sizeof(pmc);
	pmc.cb=sz;
	pal2=new ArrayList<unsigned long>;
	*pal2=*pal1;
	*pal1+=*pal2;
	al1=*pal1;
	delete pal1;
	delete pal2;
	//al2=al1;
	al1.Refresh();
	unsigned long i,t1,t2=0;
	time_t t;
	srand((unsigned int)time(&t));
	char out[100]={0};
	for(i=0;i<100;i++){
		t1=(unsigned long)(rand()%0x6000);
		t2=al1[t1];
		wsprintfA(out,"Pos %x : %lx\n",t1,t2);
		OutputDebugStringA(out);
	}
}
*/