自学教程：C++ Destory函数代码示例

void P2PProxySession::OnMessage(talk_base::Message *msg){  ASSERT(signal_thread_->IsCurrent());  switch(msg->message_id){  case DESTORY_SELFT:    {      if(p2p_connection_implementator_ != NULL){         std::cout << "delete p2p connection implementation" << std::endl;        delete p2p_connection_implementator_;        p2p_connection_implementator_ = NULL;      }      if(p2p_proxy_sockets_.size() == 0){        std::cout  << "delete proxy p2p session" << std::endl;        p2p_connection_management_->DeleteP2PProxySession(this);      }      break;    }  case CLOSE_ALL_PROXY_SOCKET:    {      break;    }  case SEND_BUFFER_DATA:    {      LOG_P2P(P2P_PROXY_SOCKET_LOGIC) << "Send command data";      if(state_ == P2P_CLOSE)        return ;      //send this string to remote peer      size_t written;      ///////////////////////////////////////////////////////////////////      //when p2p connection implementation is NULL, is can't send message      //it is normal but it very important       ///////////////////////////////////////////////////////////////////      if(p2p_connection_implementator_ == NULL || command_data_buffers_.empty()){        return ;      }      P2PCommandData *p2p_command_data = command_data_buffers_.front();      p2p_connection_implementator_->Send(0,TCP_SOCKET,         p2p_command_data->data_,p2p_command_data->len_,&written);      if(written == P2PRTSPCOMMAND_LENGTH){        command_data_buffers_.pop();        delete p2p_command_data;      }      break;    }  case RELEASE_ALL:    {      if(p2p_proxy_sockets_.size() == 0)        Destory();      break;    }  case DELAYED_CLOSE:    {      if(state_ == P2P_CLOSING){        state_ = P2P_CLOSE;        Destory();      }    }  }}

void RedBlackTree::Destory(TreeNode *T){    if (T != m_pSentinel && T != NULL )    {        Destory(T->left) ;        Destory(T->right) ;    }}

	void Destory(HuffmanNode_P<T>*& root)	{		if (root)		{			Destory(root->_left);			Destory(root->_right);						delete root;			root = NULL;		}	}

Status Destory(TREE_TYPE* tree) {	if (*tree == NULL)		return OK;	Destory(&((*tree) -> first_child));	Destory(&((*tree) -> next_sibling));	free(*tree);	*tree = NULL;	return OK;}

bool CGameSocket::SendMsg(BYTE* pBuf, int nSize){	if (pBuf == NULL || nSize <= 0)		return false;	if (m_sockClient == INVALID_SOCKET)		return false;	// 检查消息包长度	int nPackSize = 0;	nPackSize = nSize;	// 检测BUFFER溢出	if (m_nOutBufLen + nSize > OUTBUFSIZE)	{		// 立即发送OUTBUF中的数据，以清空OUTBUF		Flush();		if (m_nOutBufLen + nSize > OUTBUFSIZE)		{			// 出错了			Destory();			return false;		}	}	// 数据添加到BUF尾	memcpy(m_outBuf + m_nOutBufLen, pBuf, nSize);	m_nOutBufLen += nSize;	Flush();	return true;}

BOOL CThreadSafeCycleBufferEx::Create(LPVOID pBuff,UINT Size,UINT SmoothSize){	Destory();	CAutoLockEx FrontLock;	if(m_IsLockFront)	{		FrontLock.Lock(m_FrontLock);	}	CAutoLockEx BackLock;	if(m_IsLockBack)	{		BackLock.Lock(m_BackLock);	}		if(Size<=SmoothSize*2)	{		return FALSE;	}	m_pBuffer=(BYTE *)pBuff;	m_BufferSize=Size-SmoothSize;	m_SmoothSize=SmoothSize;	m_BufferHead=0;	m_BufferTail=0;		m_IsSelfBuffer=false;	return TRUE;}

BOOL CNetPTCPConnection::Create(UINT RecvQueueSize,UINT SendQueueSize){	if(GetServer()==NULL)		return FALSE;	Destory();	if(m_pEpollEventRouter==NULL)	{		m_pEpollEventRouter=GetServer()->CreateEventRouter();		m_pEpollEventRouter->Init(this);	}	m_Socket.MakeSocket(AF_INET,SOCK_STREAM,IPPROTO_TCP);	if(m_SendQueue.GetBufferSize()<SendQueueSize)	{		m_SendQueue.Create(SendQueueSize);	}	else	{		m_SendQueue.Clear();	}	return TRUE;}

AudioInputEngine::~AudioInputEngine(void){    if (bInit)    {        Destory();    }}

CDBTransationWorkThread::~CDBTransationWorkThread(void){	SS_TRY_BEGIN;	Destory();	SS_TRY_END();}

bool CGameSocket::Flush(){	if (m_sockClient == INVALID_SOCKET)		return false;	if (m_nOutBufLen <= 0)		return true;	int nOutSize = send(m_sockClient, m_outBuf, m_nOutBufLen, 0);	//CCLOG("send size: %d", nOutSize);	if (nOutSize > 0)	{		if (m_nOutBufLen - nOutSize > 0)		{			memcpy(m_outBuf, m_outBuf + nOutSize, m_nOutBufLen - nOutSize);		}		m_nOutBufLen -= nOutSize;		assert(m_nOutBufLen >= 0);		return Flush();	}	else	{		if (hasError())		{			Destory();			return false;		}		return true;	}}

inline void __DestoryAux(ForwardIterator first, ForwardIterator last, __FalseType){	while (first < last)	{		Destory(&(*first));		first++;	}}

void ConformalResizing::ConstrainUnits::SetNumber(int _n){	Destory();	n = _n;	CmAssert(n != 0);	pnts = new CvPoint2D64f[n];	ind = new int[n];}

Status DeleteChild(TREE_TYPE tree, TREE_NODE* node, int position) {	if (position == 1) {		Destory(&(node -> first_child));	} else {		int order = 1;		TREE_NODE *child = node -> first_child;		while (order < position - 1) {			child = child -> next_sibling;			order++;		}		TREE_NODE *n = child -> next_sibling;		child -> next_sibling = child -> next_sibling -> next_sibling;		n -> next_sibling = NULL;		Destory(&n);	}	return OK;}

int main(int argc, char *argv[]){    ST my_st;    my_st = Init_ST();    Create(my_st , "info_file");    Traverse(my_st);    printf("Find the 14 index is %d/n",Search(my_st , 56));    Destory(my_st);}

void test_Destory(void) {	BINARY_TREE_TYPE tree = get_test_tree("1,2,3,4,5");	if (tree == NULL)		return;	Status status = Destory(&tree);	CU_ASSERT_EQUAL(status, OK);	CU_ASSERT_PTR_NULL(tree);}

        /**        * Build topology of triangle mesh        *        * @param       trimesh:     input triangle mesh        * @param       fBuildVert:  true indicate build vert_topo, or skip vert_topo        * @return      true:        success        *              false:       failed        */        bool niTriMesh2dTopo::BuildTopology(const niTriMesh2d& trimesh, bool fBuildVert)        {            Destory();            bool bStat;            if (!trimesh.IsValid())                return false;            int num_verts = trimesh.NumPoints();            int num_faces = trimesh.NumFaces();            try            {                m_v2ef_list.resize(num_verts);                m_f2ve_list.resize(num_faces);            }            catch (std::bad_alloc)            {                Destory();                return false;            }            bStat = BuildEdge2VF(trimesh);            if (!bStat)                return bStat;            bStat = BuildFace2VE(trimesh);            if (!bStat)                return bStat;            if (fBuildVert)            {                bStat = BuildVert2EF(trimesh);                if (!bStat)                    return bStat;            }            if (fBuildVert)                m_valid = true;            return true;        }

void test_Destory(void) {	Status status = ERROR;	GENERALIZED_LIST_TYPE list = getGeneralizedList("(1,2,3,4)");	if (list == NULL)		return;	status = Destory(&list);	CU_ASSERT_EQUAL(status, OK);	CU_ASSERT_PTR_NULL(list);}

voidGameEngine::Run(){    if (!mInitialized)    {        Initialize();    }    Loop();    Destory();}

void CDBValue::operator=(const CEasyTime& Value){	Destory();		DB_TIMESTAMP DBValue;	DBValue.year=((CEasyTime)Value).Year();	DBValue.month=((CEasyTime)Value).Month();	DBValue.day=((CEasyTime)Value).Day();	DBValue.hour=((CEasyTime)Value).Hour();	DBValue.minute=((CEasyTime)Value).Minute();	DBValue.second=((CEasyTime)Value).Second();	DBValue.fraction=((CEasyTime)Value).Milliseconds();	SetValue(DB_TYPE_TIMESTAMP,&DBValue,sizeof(DB_TIMESTAMP),0);}

HRESULT CTTProtectDlg::OnSendRptFinish(WPARAM wparam, LPARAM lparam){	if (m_pSendRpt)	{		m_pSendRpt->Shutdown();		m_pSendRpt->Release();	}	if (m_bClickOK)		Destory();	else		m_bSendFinish = TRUE;	return S_OK;}

void test_Destory(void) {	WordIndexList list = NULL;	Status status = 0;	status = Initial(&list);	CU_ASSERT_EQUAL(status, OK);	CU_ASSERT_PTR_NOT_NULL(list);	if (list == NULL)		return;	status = Destory(&list);	CU_ASSERT_EQUAL(status, OK);	CU_ASSERT_PTR_NULL(list);}

BOOL CGrowBuffer::Create(UINT InitSize,UINT GrowSize){	Destory();	m_BufferNodes=new BUFFER_NODE[BUFFER_NODE_INIT_SIZE];	m_BufferNodeCount=BUFFER_NODE_INIT_SIZE;	m_UsedBufferNodeCount=1;	m_CurBufferNodeIndex=0;	m_BufferSize=InitSize;	m_UsedSize=0;	m_FirstSize=InitSize;	m_GrowSize=GrowSize;	m_BufferNodes[0].pBuffer=new char[m_FirstSize];	m_BufferNodes[0].BufferSize=m_FirstSize;	m_BufferNodes[0].UsedSize=0;	return TRUE;}

void  Monster_UI::updateWay(){	if (isDone == false)return;	if (queue_way.size() <= 0)	{		auto x = (Scene_UI*)sprite->getParent();		if (x->view_king != 0)		{			x->view_king->beenAttack(damage);			Destory(true);		}		return;	}	float len = abs(sprite->getPosition().x - (queue_way.front().x * 80 + 40)) +		abs(sprite->getPosition().y - (queue_way.front().y * 80 + 40));	auto a2 = MoveTo::create(0.0001*moveSpeed*len,		PublicFunc::convertToPoint(queue_way.front().x, queue_way.front().y)		);	a2->setTag(2);	sprite->runAction(a2);	auto a3 = Sequence::create(		DelayTime::create(0.0001*moveSpeed*len)		, CallFunc::create([=]()	{		isDone = true;		queue_way.pop();	}), nullptr);	a3->setTag(3);	sprite->runAction(a3);	isDone = false;}

BOOL CVideoRect::Create(LPCTSTR FileName,bool ForceLoadDirectVobSub){	if(m_pRender==NULL)		return FALSE;	Destory();	m_SubMesh.GetMaterial().ClearAllTexture();	m_pVideoTexture=new CD3DVideoTexture();	m_pVideoTexture->SetManager(m_pRender->GetDevice()->GetTextureManager());	m_pVideoTexture->EnableForceLoadVobSub(ForceLoadDirectVobSub);	m_SubMesh.GetMaterial().AddTexture(m_pVideoTexture,0,"","");	m_pVideoTexture->AddUseRef();	CD3DFX * pFX=m_pRender->GetDevice()->GetFXManager()->		LoadFXFromMemory("DefaultVideoFX",DEFAULT_VIDEO_FX,(int)strlen(DEFAULT_VIDEO_FX));	if(pFX)	{		m_SubMesh.GetMaterial().SetFX(pFX);			}				if(!m_pVideoTexture->Create(FileName))	{		m_pVideoTexture->Destory();		return FALSE;	}			m_pRender->GetDevice()->GetTextureManager()->AddTexture(m_pVideoTexture,m_pVideoTexture->GetName());	//int Width,Height;	//m_pVideoTexture->GetVideoSize(Width,Height);	//m_Rect.left=0;	//m_Rect.top=0;	//m_Rect.right=Width;	//m_Rect.bottom=Height;	CreateVertex();	SetVisible(true);	return TRUE;}

bool CNetConnection::StealFrom(CNameObject * pObject,UINT Param){	CAutoLock Lock1(m_RecvLock);	CAutoLock Lock2(m_SendLock);	PrintNetLog(0xffffffff,"(%d)执行连接替换(%d)！",GetID(),pObject->GetID());	if(pObject->IsKindOf(GET_CLASS_INFO(CNetConnection)))	{		Destory();		if(!CNameObject::StealFrom(pObject,Param))			return false;		CNetConnection * pConnection=(CNetConnection *)pObject;		if(!m_Socket.StealFrom(&(pConnection->m_Socket),Param))			return false;				m_pServer=pConnection->m_pServer;		m_WantClose=pConnection->m_WantClose;		m_pEpollEventRouter=pConnection->m_pEpollEventRouter;		pConnection->m_pEpollEventRouter=NULL;		if(m_pEpollEventRouter)			m_pEpollEventRouter->SetEventHander(this);						CEpollEventObject * pEpollEventObject;		m_RecvQueue.Create(pConnection->m_RecvQueue.GetBufferSize());				while(pConnection->m_RecvQueue.PopFront(pEpollEventObject))		{			m_RecvQueue.PushBack(pEpollEventObject);		}				m_SendQueue.Create(pConnection->m_SendQueue.GetBufferSize());				while(pConnection->m_SendQueue.PopFront(pEpollEventObject))		{			m_SendQueue.PushBack(pEpollEventObject);		}			return true;			}	return false;}

void shortext_path_build_result(GRAPHIC_TYPE graphic, 		VERTEX_TYPE *vertex, 		int* path, 		ShortestPathResultNode** result) {	int i = 0, j = 0, count = 0;	int vertex_count = graphic -> vertex_count;	int vertex_index = vertex - graphic -> vertex_list;	*result = (ShortestPathResultNode*)malloc(sizeof(ShortestPathResultNode) * vertex_count - 1);	for (i = 0; i < vertex_count; i++) {		if (i == vertex_index) {			continue;		}		(*result + count) -> end_vertex = (AdjacentMatrixGraphicVertex*)malloc(sizeof(AdjacentMatrixGraphicVertex));		(*result + count) -> end_vertex -> is_empty = FALSE;		(*result + count) -> end_vertex -> value = (graphic -> vertex_list)[i].value;		AdjacentMatrixGraphic *result_graphic = &((*result + count) -> graphic);		Initial(result_graphic);		int start_vertex_index = vertex_index;		for (j = 0; j < vertex_count; j++) {			int end_vertex_index = path[i * vertex_count + j];			if (end_vertex_index == -1) {				continue;			}			AdjacentMatrixGraphicVertex *start_vertex = graphic -> vertex_list + start_vertex_index;			AdjacentMatrixGraphicVertex *end_vertex = graphic -> vertex_list + end_vertex_index;			int arc_weight = (graphic -> arc_list)[start_vertex_index][end_vertex_index];			result_insert_arc(result_graphic, start_vertex, end_vertex, arc_weight);			start_vertex_index = end_vertex_index;		}		if (start_vertex_index == vertex_index) {			Destory(result_graphic);		}		count++;	}}