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

//virtualvoid LLConsole::clear(){	mTimer.reset();	LLMutexLock lock(&mQueueMutex);	std::for_each(mParagraphs.begin(), mParagraphs.end(), DeletePointer());	mParagraphs.clear();	std::for_each(mNewParagraphs.begin(), mNewParagraphs.end(), DeletePointer());	mNewParagraphs.clear();}

////-----------------/// FFMultiSet::clear//---------------------//	Cleans up.//void FFMultiSet::clear(){	mConfig = NULL;	for	(	int i = 0	;	i < mSet.size()	;	i++	){		DeletePointer( mSet[ i ] );	}	mSet.clear();	DeletePointer( mDevices );}

// Destroys the objectLLFloaterPay::~LLFloaterPay(){	std::for_each(mCallbackData.begin(), mCallbackData.end(), DeletePointer());	// Clean up if we are still waiting for a name.	gCacheName->cancelCallback(mTargetUUID,onCacheOwnerName,this);}

LLViewerRegion::~LLViewerRegion() {	if(mHttpResponderPtr)	{		(static_cast<BaseCapabilitiesComplete*>(mHttpResponderPtr.get()))->setRegion(NULL) ;	}	gVLManager.cleanupData(this);	// Can't do this on destruction, because the neighbor pointers might be invalid.	// This should be reference counted...	disconnectAllNeighbors();	mCloudLayer.destroy();	LLViewerPartSim::getInstance()->cleanupRegion(this);	gObjectList.killObjects(this);	delete mCompositionp;	delete mParcelOverlay;	delete mLandp;	delete mEventPoll;	LLHTTPSender::clearSender(mHost);		saveObjectCache();	std::for_each(mObjectPartition.begin(), mObjectPartition.end(), DeletePointer());}

void LLDrawable::destroy(){	if (gDebugGL)	{		gPipeline.checkReferences(this);	}	if (isDead())	{		sNumZombieDrawables--;	}	if (LLSpatialGroup::sNoDelete)	{		llerrs << "Illegal deletion of LLDrawable!" << llendl;	}	std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());	mFaces.clear();				/*if (!(sNumZombieDrawables % 10))	{		llinfos << "- Zombie drawables: " << sNumZombieDrawables << llendl;	}*/	}

void LLXferManager::cleanup (){	LLXfer *xferp;	LLXfer *delp;	for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());	mOutgoingHosts.clear();	delp = mSendList;	while (delp)	{		xferp = delp->mNext;		delete delp;		delp = xferp;	}	mSendList = NULL;	delp = mReceiveList;	while (delp)	{		xferp = delp->mNext;		delete delp;		delp = xferp;	}	mReceiveList = NULL;}

LLCacheName::Impl::~Impl(){    for_each(mCache.begin(), mCache.end(), DeletePairedPointer());    mCache.clear();    for_each(mReplyQueue.begin(), mReplyQueue.end(), DeletePointer());    mReplyQueue.clear();}

LLBufferArray::~LLBufferArray(){	LLMemType m1(LLMemType::MTYPE_IO_BUFFER);	std::for_each(mBuffers.begin(), mBuffers.end(), DeletePointer());	delete mMutexp;}

LLCurlRequest::~LLCurlRequest(){	llassert_always(mThreadID == LLThread::currentID());	//stop all Multi handle background threads	for (curlmulti_set_t::iterator iter = mMultiSet.begin(); iter != mMultiSet.end(); ++iter)	{		LLCurl::Multi* multi = *iter;		if (multi->mThreaded)			multi->mSignal->lock();		multi->mQuitting = true;		if (multi->mThreaded)		{			while (!multi->isStopped())			{				multi->mSignal->signal();				multi->mSignal->unlock();				apr_sleep(1000);				multi->mSignal->lock();			}		}		if (multi->mThreaded)			multi->mSignal->unlock();	}	for_each(mMultiSet.begin(), mMultiSet.end(), DeletePointer());}

LLCurl::Multi::~Multi(){	llassert(isStopped());	if (LLCurl::sMultiThreaded)	{		LLCurl::Easy::sMultiMutex->lock();	}	delete mSignal;	mSignal = NULL;	// Clean up active	for(easy_active_list_t::iterator iter = mEasyActiveList.begin();		iter != mEasyActiveList.end(); ++iter)	{		Easy* easy = *iter;		check_curl_multi_code(curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle()));		delete easy;	}	mEasyActiveList.clear();	mEasyActiveMap.clear();		// Clean up freed	for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer());		mEasyFreeList.clear();	check_curl_multi_code(curl_multi_cleanup(mCurlMultiHandle));	--gCurlMultiCount;	if (LLCurl::sMultiThreaded)	{		LLCurl::Easy::sMultiMutex->unlock();	}}

void LLCurl::cleanupClass(){#if SAFE_SSL    CRYPTO_set_locking_callback(NULL);    for_each(sSSLMutex.begin(), sSSLMutex.end(), DeletePointer());#endif    curl_global_cleanup();}

// Destroys the objectLLFloaterPay::~LLFloaterPay(){	std::for_each(mCallbackData.begin(), mCallbackData.end(), DeletePointer());	// Name callbacks will be automatically disconnected since LLFloater is trackable		// In case this floater is currently waiting for a reply.	gMessageSystem->setHandlerFuncFast(_PREHASH_PayPriceReply, 0, 0);}

LLToastNotifyPanel::~LLToastNotifyPanel(){    mButtonClickConnection.disconnect();    std::for_each(mBtnCallbackData.begin(), mBtnCallbackData.end(), DeletePointer());    mBtnCallbackData.clear();    if (mIsTip)    {        LLNotifications::getInstance()->cancel(mNotification);    }}

// virtualLLNotifyBox::~LLNotifyBox(){	delete mBehavior;	mBehavior = NULL;	std::for_each(mBtnCallbackData.begin(), mBtnCallbackData.end(), DeletePointer());	if (mUnique)	{		sOpenUniqueNotifyBoxes.erase(getName() + mMessage);	}}

LLToastNotifyPanel::~LLToastNotifyPanel() {	mButtonClickConnection.disconnect();	std::for_each(mBtnCallbackData.begin(), mBtnCallbackData.end(), DeletePointer());	if (mCloseNotificationOnDestroy && LLNotificationsUtil::find(mNotification->getID()) != NULL)	{		// let reusable notification be deleted		mNotification->setReusable(false);		LLNotifications::getInstance()->cancel(mNotification);	}}

// Called from either the main thread or the worker threadvoid LLTextureCache::readHeaderCache(apr_pool_t* poolp){	LLMutexLock lock(&mHeaderMutex);	mHeaderEntriesInfo.mVersion = 0.f;	mHeaderEntriesInfo.mEntries = 0;	if (ll_apr_file_exists(mHeaderEntriesFileName, poolp))	{		ll_apr_file_read_ex(mHeaderEntriesFileName, poolp,							(U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));	}	if (mHeaderEntriesInfo.mVersion != sHeaderCacheVersion)	{		if (!mReadOnly)		{			// Info with 0 entries			mHeaderEntriesInfo.mVersion = sHeaderCacheVersion;			ll_apr_file_write_ex(mHeaderEntriesFileName, poolp,								 (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));		}	}	else	{		S32 num_entries = mHeaderEntriesInfo.mEntries;		if (num_entries)		{			Entry* entries = new Entry[num_entries];			ll_apr_file_read_ex(mHeaderEntriesFileName, poolp,								(U8*)entries, sizeof(EntriesInfo), num_entries*sizeof(Entry));			typedef std::set<lru_data*, lru_data::Compare> lru_set_t;			lru_set_t lru;			for (S32 i=0; i<num_entries; i++)			{				if (entries[i].mSize >= 0) // -1 indicates erased entry, skip				{					const LLUUID& id = entries[i].mID;					lru.insert(new lru_data(entries[i].mTime, i, id));					mHeaderIDMap[id] = i;				}			}			mLRU.clear();			S32 lru_entries = sCacheMaxEntries / 10;			for (lru_set_t::iterator iter = lru.begin(); iter != lru.end(); ++iter)			{				lru_data* data = *iter;				mLRU[data->index] = data->uuid;				if (--lru_entries <= 0)					break;			}			for_each(lru.begin(), lru.end(), DeletePointer());			delete[] entries;		}	}}

LLLayoutStack::~LLLayoutStack(){	// <FS:Zi> Save new sizes for this layout stack's panels	if (mSaveSizes)	{		LLUI::sSettingGroups["account"]->setLLSD(mSizeControlName, mSavedSizes);	}	// </FS:Zi>	e_panel_list_t panels = mPanels; // copy list of panel pointers	mPanels.clear(); // clear so that removeChild() calls don't cause trouble	std::for_each(panels.begin(), panels.end(), DeletePointer());}

void LLScrollListItem::setNumColumns(S32 columns){	S32 prev_columns = mColumns.size();	if (columns < prev_columns)	{		std::for_each(mColumns.begin()+columns, mColumns.end(), DeletePointer());	}		mColumns.resize(columns);	for (S32 col = prev_columns; col < columns; ++col)	{		mColumns[col] = NULL;	}}

void LLFloaterReporter::setDescription(const std::string& description, LLMeanCollisionData *mcd){	LLFloaterReporter *self = gReporterInstances[COMPLAINT_REPORT];	if (self)	{		self->childSetText("details_edit", description);		for_each(self->mMCDList.begin(), self->mMCDList.end(), DeletePointer());		self->mMCDList.clear();		if (mcd)		{			self->mMCDList.push_back(new LLMeanCollisionData(mcd));		}	}}

void LLDrawable::cleanupReferences(){	LLFastTimer t(LLFastTimer::FTM_PIPELINE);		std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());	mFaces.clear();	gObjectList.removeDrawable(this);		gPipeline.unlinkDrawable(this);		// Cleanup references to other objects	mVObjp = NULL;	mParent = NULL;}

FFSet::~FFSet(){	for	(	TInclude::iterator itInclude = mInclude.begin()	;	itInclude != mInclude.end()	;	itInclude++	){		for		(	TProject::iterator itProject = (*itInclude).begin()		;	itProject != (*itInclude).end()		;	itProject++		){			DeletePointer( (*itProject).second );		}	}}

//-----------------------------------------------------------------------------// deleteAllMotions()//-----------------------------------------------------------------------------void LLMotionController::deleteAllMotions(){	mLoadingMotions.clear();	mLoadedMotions.clear();	mActiveMotions.clear();	//<singu>	mActiveMask = 0;	for_each(mDeprecatedMotions.begin(), mDeprecatedMotions.end(), DeletePointer());	mDeprecatedMotions.clear();	for (motion_map_t::iterator iter = mAllMotions.begin(); iter != mAllMotions.end(); ++iter)	{		iter->second->unregister_client();	}	//</singu>	for_each(mAllMotions.begin(), mAllMotions.end(), DeletePairedPointer());	mAllMotions.clear();}

// virtualLLFloaterReporter::~LLFloaterReporter(){	// child views automatically deleted	mObjectID 		= LLUUID::null;	if (mPicking)	{		closePickTool(this);	}	mPosition.setVec(0.0f, 0.0f, 0.0f);	std::for_each(mMCDList.begin(), mMCDList.end(), DeletePointer() );	mMCDList.clear();	delete mResourceDatap;}

void LLCurl::Multi::cleanup(bool deleted){	if(!mCurlMultiHandle)	{		return ; //nothing to clean.	}	llassert_always(deleted || !mValid) ;	LLMutexLock lock(mDeletionMutexp);		// Clean up active	for(easy_active_list_t::iterator iter = mEasyActiveList.begin();		iter != mEasyActiveList.end(); ++iter)	{		Easy* easy = *iter;		check_curl_multi_code(curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle()));		if(deleted)		{			easy->mResponder = NULL ; //avoid triggering mResponder.		}		delete easy;	}	mEasyActiveList.clear();	mEasyActiveMap.clear();		// Clean up freed	for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer());		mEasyFreeList.clear();	check_curl_multi_code(LLCurl::deleteMultiHandle(mCurlMultiHandle));	mCurlMultiHandle = NULL ;		delete mMutexp ;	mMutexp = NULL ;	delete mEasyMutexp ;	mEasyMutexp = NULL ;	mQueued = 0 ;	mState = STATE_COMPLETED;		--gCurlMultiCount;	return ;}

// virtualLLFloaterReporter::~LLFloaterReporter(){	gReporterInstances.removeData(mReportType);	// child views automatically deleted	mObjectID 		= LLUUID::null;	if (mPicking)	{		closePickTool(this);	}	mPosition.setVec(0.0f, 0.0f, 0.0f);	std::for_each(mMCDList.begin(), mMCDList.end(), DeletePointer() );	mMCDList.clear();	delete mResourceDatap;	gDialogVisible = FALSE;}

LLCurl::Multi::~Multi(){    // Clean up active    for(easy_active_list_t::iterator iter = mEasyActiveList.begin();            iter != mEasyActiveList.end(); ++iter)    {        Easy* easy = *iter;        curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle());        delete easy;    }    mEasyActiveList.clear();    mEasyActiveMap.clear();    // Clean up freed    for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer());    mEasyFreeList.clear();    curl_multi_cleanup(mCurlMultiHandle);    --gCurlMultiCount;}

void LLDrawable::cleanupReferences(){	LLFastTimer t(FTM_CLEANUP_DRAWABLE);		{		LLFastTimer t(FTM_DELETE_FACES);		std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());		mFaces.clear();	}	gObjectList.removeDrawable(this);		gPipeline.unlinkDrawable(this);		{		LLFastTimer t(FTM_DEREF_DRAWABLE);		// Cleanup references to other objects		mVObjp = NULL;		mParent = NULL;	}}

void LLTabContainer::deleteAllTabs(){	// Remove all the tab buttons and delete them.  Also, unlink all the child panels.	for(std::vector<LLTabTuple*>::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)	{		LLTabTuple* tuple = *iter;		removeChild( tuple->mButton );		delete tuple->mButton; 		removeChild( tuple->mTabPanel );// 		delete tuple->mTabPanel;	}	// Actually delete the tuples themselves	std::for_each(mTabList.begin(), mTabList.end(), DeletePointer());	mTabList.clear();		// And there isn't a current tab any more	mCurrentTabIdx = -1;}