IOCP 분 층 2, 복잡 도 1 의 대상 풀 포 지 셔 닝

전편
IOCP 의 레이 어 링 1
 
 
대상 탱크 의 사용 에 있어 서 나 는 앞에서 쓴 배열 시 뮬 레이 션 링크 의 구 조 를 사용 하고 수정 했다.가장 큰 발견 은 STL 의 편 특 화 특성 으로 인해 공간 을 NEW 로 설정 할 수 없 게 되 었 고 VECTOR 의 표준 구조 에 서 는 이 블록 을 숨 겼 습 니 다. 사용 자 는 끊임없이 PUSH 를 사용 하면 됩 니 다.그러나 해결 방법 은 당연히 있 습 니 다. 코드 를 수정 한 후에 좀 추 했 습 니 다.
ListofArray. h 코드

#pragma once

#include <assert.h>
/**
V0.2 2010/04/15
      add    ，     operate =    。           ，    C++     ，        
operate    。      ，        ，                   。               ，
      (ELEMENT ElementData[llist_size])              ID，           ，  operate=，  
     ，             ，    ，    。              :
1.          
2.       ，  new   
3.   STL     ,      ,         ,       llist_size

v0.1
*     ,           ,                 。         
*    /     .
*          
*      NULL  
*
*        
* ：     ，      。
* ：        ELEMENT  ，          。           
*          ，    ELEMENT，          。                  
*      ，     (          )
*ELEMENT       ：typedef CListOfArray<type, 1000>::ELEMENT CListOfArray_t;
*    CListOfArray_t  
**/
template<typename llist_t, int llist_size=100, bool bManual=false>
class CListOfArray
{
	//variable
public:
	struct ELEMENT
	{
		llist_t element;
		ELEMENT* pPre;
		ELEMENT* pNext;
	};

private:	
	int nMaxElementItem;
	ELEMENT *ElementData/*[llist_size]*/;//    

	ELEMENT ElementFreeHead;			//       
	ELEMENT ElementUseHead;             //         

	int nFreeSum;
	int nUseSum;

	//function
public:
	CListOfArray()
	{
		nMaxElementItem = llist_size;
		if( false == bManual )
		{
			InitList();
		}		
	}
	~CListOfArray()
	{
		delete []ElementData;
	}

	void ManualAlloct(int nManualMaxItem)
	{
		nMaxElementItem = nManualMaxItem;
		InitList();
	}

	bool Add(const llist_t e);
	ELEMENT* GetMallocElement()
	{
		return MallocElement();
	}
	
	ELEMENT* Erase(ELEMENT *p)
	{
		return ReleaseElement(p);
	}

	void Empty();	

	ELEMENT* GetListUseHead()
	{
		return ElementUseHead.pNext;
	}
	
	ELEMENT* GetListFreeHead()
	{
		return ElementFreeHead.pNext;
	}

	int GetSumElementUse()
	{
		return nUseSum;
	}

	int GetSumElementFree()
	{
		return nFreeSum;
	}

private:		
	void InitList();
	ELEMENT* MallocElement();
	ELEMENT* ReleaseElement(ELEMENT *p);

	//
	//    
	void AddNodeToList(ELEMENT* const pNode, ELEMENT* const pDesListHead)
	{		
		pNode->pNext = pDesListHead->pNext;
		pNode->pPre  = pDesListHead;

		//
		//   NULL  ,     。  linux list        
		if( NULL!=pDesListHead->pNext )
		{
			pDesListHead->pNext->pPre = pNode;
		}

		pDesListHead->pNext = pNode;
	}
};

/**
*         
**/
template <typename llist_t, int llist_size, bool bManual>
void CListOfArray<llist_t, llist_size, bManual>::InitList()
{
	assert( nMaxElementItem>0 );
	ElementData = new ELEMENT[nMaxElementItem];
	nUseSum = 0;
	nFreeSum = llist_size;

	//     
	for(int i=0; i<nMaxElementItem-1; ++i)
	{
		ElementData[i].pNext = &ElementData[i+1];
	}

	ElementData[nMaxElementItem-1].pNext = NULL;

	ElementUseHead.pNext = NULL;
	ElementFreeHead.pNext = &ElementData[0];
}

template <typename llist_t, int llist_size, bool bManual>
typename CListOfArray<llist_t, llist_size, bManual>::ELEMENT* CListOfArray<llist_t, llist_size, bManual>::MallocElement()
{
	//         
	if( NULL==ElementFreeHead.pNext )
	{
		return NULL;
	}

	--nFreeSum;
	++nUseSum;
	// Free    ,  
	ELEMENT* p = ElementFreeHead.pNext;
	ElementFreeHead.pNext = ElementFreeHead.pNext->pNext;

	AddNodeToList(p, &ElementUseHead);

	return p;
}

template <typename llist_t, int llist_size, bool bManual>
typename CListOfArray<llist_t, llist_size, bManual>::ELEMENT* CListOfArray<llist_t, llist_size, bManual>::ReleaseElement( ELEMENT *p)
{
	--nUseSum;
	++nFreeSum;
	ELEMENT *pResult = p->pNext;
	// Use    
	p->pPre->pNext = p->pNext;
	//        
	if( NULL!=p->pNext )
	{
		p->pNext->pPre = p->pPre;	
	}

	AddNodeToList(p, &ElementFreeHead);

	return pResult;
}

template <typename llist_t, int llist_size, bool bManual>
bool CListOfArray<llist_t, llist_size, bManual>::Add(const llist_t e)
{
	//  Free          
	ELEMENT *p = MallocElement();

	if( NULL==p )
	{
		return false;
	}
	else
	{
		p->element = e;
		return true;
	}
}

template <typename llist_t, int llist_size, bool bManual>
void CListOfArray<llist_t, llist_size, bManual>::Empty()
{
	//
	//       ElementUseHead    ElementFreeHead  。         ，Empty      
	//     ，   Erase
	ELEMENT* p = GetListHead();

	while( NULL!=p )
	{
		p = Erase(p);
		continue;

		p=p->pNext;
	}
}

 
 Main 파일 의 호출 코드:

// HelloTest.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "ListOfArray.h"

const int MAX_TESTOBJECT_ITEM = 100;
const int MAX_MANUAL_TESTOBJECT_ITEM = 100;

class CNet
{
public:
	bool bEnable;
	int nIdenti;

private:
	

public:
	CNet()
	{
		bEnable = false;
	}
private:
};

class CLogic
{
public:
	bool bEnable;
	int nIdenti;

private:
	

public:
	CLogic()
	{
		bEnable = false;
	}

private:
};

typedef CListOfArray<CNet,MAX_TESTOBJECT_ITEM, true> CListOfArrayT;
typedef CListOfArray<CNet,MAX_TESTOBJECT_ITEM, true>::ELEMENT CListOfArray_t;

//
//
void PrintListInfo(CListOfArrayT *pNetList)
{
	cout<<"PrintListInfo--------:"<<endl;	
	cout<<"SumUse:"<<pNetList->GetSumElementUse()<<endl;
	cout<<"SumFree:"<<pNetList->GetSumElementFree()<<endl;
}


bool Connect(CListOfArrayT *pNetList, CLogic *pLogicArray)
{
	CListOfArray_t *pGetNetItem = pNetList->GetMallocElement();
	if( NULL==pGetNetItem )
	{
		return false;
	}

	pGetNetItem->element.bEnable = true;
	pLogicArray[ pGetNetItem->element.nIdenti ].bEnable = true;
	
	return true;
}

void DisConnect(CListOfArrayT *pNetList, CLogic *pLogicArray)
{
	int nSumUse = pNetList->GetSumElementUse();
	CListOfArray_t *pGetNetItem = pNetList->GetListUseHead();

	if( 0==nSumUse )
	{
		//
		//     
		return;
	}

	int nErase = rand()%nSumUse;
	for(int i=0; i<nErase; ++i)
	{
		pGetNetItem = pGetNetItem->pNext;
	}

	pGetNetItem->element.bEnable = false; 
	pLogicArray[ pGetNetItem->element.nIdenti ].bEnable = false;
	pNetList->Erase(pGetNetItem);
}

void TestStep1( CListOfArrayT *pNetList, CLogic *pLogicArray, int nCount)
{
	for(int i=0; i<nCount; ++i)
	{
		if( false==Connect(pNetList, pLogicArray))
		{
			cout<<"step 1 Connect Full"<<endl;
		}
	}
}

void TestStep2( CListOfArrayT *pNetList, CLogic *pLogicArray, int nCount)
{
	for(int i=0; i<nCount; ++i)
	{
		int j=rand()%2;
		if( 0==j )
		{
			//  
			if( false==Connect(pNetList, pLogicArray))
			{
				cout<<"step 2 Connect Full"<<endl;
			}
		}
		else
		{
			//    
			DisConnect(pNetList, pLogicArray);
		}
	}	
}

void VerifyEnable(CListOfArrayT *pNetList, CLogic *pLogicArray)
{
	cout<<"VerifyEnable--------:"<<endl;
	//
	//      
	int nSumNetList = pNetList->GetSumElementUse();
	int nSumLogicArray = 0;
	
	for(int i=0; i<MAX_TESTOBJECT_ITEM; ++i)
	{
		if( true==pLogicArray[i].bEnable )
		{
			nSumLogicArray++;
		}
	}

	cout<<"nSumNetList:"<<nSumNetList<<endl;
	cout<<"nSumLogicArray:"<<nSumLogicArray<<endl;

	//
	//  Identi  
	int nLogicArrayIndex;
	CListOfArray_t *pGetNetUseItem = pNetList->GetListUseHead();
	CListOfArray_t *pGetNetFreeItem = pNetList->GetListFreeHead();


	for(; NULL!=pGetNetUseItem; pGetNetUseItem=pGetNetUseItem->pNext)
	{
		nLogicArrayIndex = pGetNetUseItem->element.nIdenti; 
		if( pGetNetUseItem->element.bEnable!=pLogicArray[nLogicArrayIndex].bEnable )
		{
			cout<<nLogicArrayIndex<<"	error!!!!!"<<endl;
		}
	}

	for(; NULL!=pGetNetFreeItem; pGetNetFreeItem=pGetNetFreeItem->pNext)
	{
		nLogicArrayIndex = pGetNetFreeItem->element.nIdenti; 
		if( pGetNetFreeItem->element.bEnable!=pLogicArray[nLogicArrayIndex].bEnable )
		{
			cout<<nLogicArrayIndex<<"	error!!!!!"<<endl;
		}	
	}

}

int _tmain(int argc, _TCHAR* argv[])
{
	srand( (unsigned)time( NULL ) );

	int i;
	CListOfArrayT NetList;
	CLogic LogicArray[MAX_TESTOBJECT_ITEM];

	NetList.ManualAlloct(MAX_TESTOBJECT_ITEM);
	//
	//ID   	CListOfArray_t *pListItem = NetList.GetListFreeHead();
	for(i=0; i<MAX_TESTOBJECT_ITEM; ++i)
	{
		pListItem->element.nIdenti = i;
		LogicArray[i].nIdenti = i;

		pListItem = pListItem->pNext;
		
	}
	
	TestStep1(&NetList, LogicArray, 982);	
	TestStep2(&NetList, LogicArray, 3000);


	TestStep1(&NetList, LogicArray, 910);	
	TestStep2(&NetList, LogicArray, 600);
	TestStep2(&NetList, LogicArray, 760);

	//
	//  ID  
	VerifyEnable(&NetList, LogicArray);

	//
	//      
	PrintListInfo(&NetList);
	PrintArrayInfo(LogicArray);

	

	return 0;
}

 나 는 호출 에서 연결 이 들 어 온 후에 네트워크 대상 에서 대상 을 얻 은 다음 에 비교 하 는 것 도 상부 의 논리 에서 얻 었 다.원 리 는 간단 하고 서열 화 된 ID 입 니 다.Main 의 코드 는 주로 두 대상 의 집합 간 의 값 이 일일이 대응 하 는 지 비교 합 니 다.아직 버그 가 발견 되 지 않 았 습 니 다. 제출 을 환영 합 니 다.