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

moDMatrix<Real>& moDMatrix<Real>::operator= (const moDMatrix& rkM){    if (rkM.m_iQuantity > 0)    {        if (m_iRows != rkM.m_iRows || m_iCols != rkM.m_iCols)        {            Deallocate();            m_iRows = rkM.m_iRows;            m_iCols = rkM.m_iCols;            m_iQuantity = rkM.m_iQuantity;            Allocate(false);        }        for (int iRow = 0; iRow < m_iRows; iRow++)        {            for (int iCol = 0; iCol < m_iCols; iCol++)            {                m_aafEntry[iRow][iCol] = rkM.m_aafEntry[iRow][iCol];            }        }    }    else    {        Deallocate();        m_iRows = 0;        m_iCols = 0;        m_iQuantity = 0;        m_afData = 0;        m_aafEntry = 0;    }    return *this;}

BSplineBasis<Real>::~BSplineBasis (){	delete1(mKnot);	Deallocate(mBD0);	Deallocate(mBD1);	Deallocate(mBD2);	Deallocate(mBD3);}

Adventure::ITexture* Adventure::Image::LoadTgaFromFile(File& file, IDisplay& display, Allocator* scratch){	file.GetStream().seekg(2, std::ios::beg);		File::UInt8 type;	file.Read(type);		if (type != 2) // Type 2 indicates a regular image		return NULL;		file.GetStream().seekg(12, std::ios::beg);		File::UInt16 width, height;	file.Read(width);	file.Read(height);		int pixels = width * height;		file.GetStream().seekg(16, std::ios::beg);		File::UInt8 bits;	file.Read(bits);		if (bits < 24)		return NULL;		file.GetStream().seekg(18, std::ios::beg);		Color* pixelData = new(scratch) Color[pixels];		for (int i = 0; i < pixels; i++)	{		// BGRA format		file.Read(pixelData[i].Blue);		file.Read(pixelData[i].Green);		file.Read(pixelData[i].Red);				if (bits == 32)			file.Read(pixelData[i].Alpha);		else			pixelData[i].Alpha = Color::MaxChannelValue;	}		ITexture* texture = display.CreateTexture();		if (texture == NULL)	{		Deallocate(pixelData, scratch);		return NULL;	}		texture->SetData(pixelData, width, height, ITexture::Rgba8, ITexture::Point);		Deallocate(pixelData, scratch);			return texture;}

template <class T> void Vector<T>::CopyToSelf(Vector const & source){	UInt length;	ConstElement *it, *source_it, *source_end;	Deallocate();	_ctorMode = source._ctorMode;	if(!source.IsEmpty())	{		length = source.Length();		Allocate(length);		it = _origin;		source_it = source.Begin();		source_end = source.End();		if(_ctorMode != CtorModeEnum::Always)		{			Memory::Move((VoidPtr)source_it, (VoidPtr)it, sizeof(Element) * length);			_last += length;		}		else			while(source_it != source_end)			{				Construct(it++, source_it++);				++_last;			}	}}

voidMediaEngineWebRTCVideoSource::Shutdown(){  LOG((__FUNCTION__));  if (!mInitDone) {    return;  }#ifdef MOZ_B2G_CAMERA  ReentrantMonitorAutoEnter sync(mCallbackMonitor);#endif  if (mState == kStarted) {    while (!mSources.IsEmpty()) {      Stop(mSources[0], kVideoTrack); // XXX change to support multiple tracks    }    MOZ_ASSERT(mState == kStopped);  }  if (mState == kAllocated || mState == kStopped) {    Deallocate();  }#ifndef MOZ_B2G_CAMERA  mViECapture->Release();  mViERender->Release();  mViEBase->Release();#endif  mState = kReleased;  mInitDone = false;}

	void EpsilonVor::ReadIt(std::ifstream & fin){		Matrix co0,oc0;		fin.read((char *) &nnx, sizeof nnx);		fin.read((char *) &nny, sizeof nny);		fin.read((char *) &nnz, sizeof nnz);		fin.read((char *) &co0, sizeof co0);		fin.read((char *) &oc0, sizeof oc0);		fin.read((char *) &nresid, sizeof nresid);		Deallocate();		is_xRefset=true;		is_COset=true;		setMetric(co0);		Allocate();		int ntoken;		fin.read((char *) &ntoken, sizeof ntoken);		char * css=new char [ntoken];		fin.read(css, (sizeof css[0])*ntoken);		string token(css);		ResLabel.clear();		boost::split(ResLabel,token, boost::is_any_of("/t "));		fin.read((char *) &TotalCount, sizeof TotalCount);		fin.read((char *) &M_avg[0], (sizeof M_avg[0])*DIM);		fin.read((char *) &VoroVol[0], (sizeof VoroVol[0])*nresid);		fin.read((char *) &D[0][0][0], (sizeof D[0][0][0])*DIM*DIM*nresid);		fin.read((char *) &G[0][0][0], (sizeof G[0][0][0])*DIM*DIM*nresid);		fin.read((char *) &M[0][0], (sizeof M[0][0])*DIM*nresid);		fin.read((char *) &E[0][0], (sizeof E[0][0])*DIM*nresid);	}

void Path :: Deallocate (Entry *  good){        if (good != NULL){        Deallocate (good -> next);        delete good;    }}

void DoublyLinkedListPriorityQueue:: Deallocate (Entry * & list){        if (list != NULL){        Deallocate (list -> next);        delete list;    }}

void TileGrid2D::Resize(Vector2i newSize){	std::cout<<"/nTileGrid2D::Resize";	Deallocate();	size = newSize;	/// Space in X between the columns, use for creating hexagonal grids, since the distance between each tile should always be 1.0 if possible.	float spaceX = 0;	/// Offset in Y, used for creating hexagonal grids.	Vector2f eachOtherRowOffset;	Vector2f rowSpacing(1,1);	if (gridType == GridType::HEXAGONS)	{		eachOtherRowOffset = Vector2f(0.5f, 0);		rowSpacing = Vector2f(1, 0.86602540378f);	}	for (int y = 0; y < size[1]; ++y)	{		List<Tile*> * list = new List<Tile*>();		for (int x = 0; x < size[0]; ++x)		{			Tile * tile = new Tile();			tile->position = rowSpacing.ElementMultiplication(Vector2f(x,y));			if (y % 2 == 0)				tile->position += eachOtherRowOffset;			list->Add(tile);		}		tiles.Add(list);	}}

void	CARingBuffer::Allocate(int nChannels, UInt32 bytesPerFrame, UInt32 capacityFrames){	Deallocate();		//capacityFrames = NextPowerOfTwo(capacityFrames);		mNumberChannels = nChannels;	mBytesPerFrame = bytesPerFrame;	mCapacityFrames = capacityFrames;	//mCapacityFramesMask = capacityFrames - 1;	mCapacityBytes = bytesPerFrame * capacityFrames;	// put everything in one memory allocation, first the pointers, then the deinterleaved channels	UInt32 allocSize = (mCapacityBytes + sizeof(Byte *)) * nChannels;	Byte *p = (Byte *)CA_malloc(allocSize);	memset(p, 0, allocSize);	mBuffers = (Byte **)p;	p += nChannels * sizeof(Byte *);	for (int i = 0; i < nChannels; ++i) {		mBuffers[i] = p;		p += mCapacityBytes;	}		for (UInt32 i = 0; i<kGeneralRingTimeBoundsQueueSize; ++i)	{		mTimeBoundsQueue[i].mStartTime = 0;		mTimeBoundsQueue[i].mEndTime = 0;		mTimeBoundsQueue[i].mUpdateCounter = 0;	}	mTimeBoundsQueuePtr = 0;}

void CTexture::Allocate( int width, int height, int ctype ){if ( (m_width == width) && (m_height == height) && (m_type == ctype) )	return;Deallocate();TextureGetSize( ctype, &m_compsize, &m_pixelsize, &m_nelements );if ( m_compsize == 0 || m_pixelsize == 0 || m_nelements == 0)     // Sanity check 	{	printf ("CTexture::Allocate - Unknown format %08X/n", ctype );  return;	}m_width  = width;m_height = height;m_area   = width * height;m_type   = ctype;m_size   = m_area * m_pixelsize;m_pdata  = new TEXBYTE[m_size];m_pitch  = m_pixelsize * m_width;if ( ctype == TEX_PALETTE )		m_pcolormap = new colmap4f[256];}

voidMediaEngineWebRTCVideoSource::Shutdown(){  LOG((__FUNCTION__));  if (!mInitDone) {    return;  }  if (mState == kStarted) {    SourceMediaStream *source;    bool empty;    while (1) {      {        MonitorAutoLock lock(mMonitor);        empty = mSources.IsEmpty();        if (empty) {          break;        }        source = mSources[0];      }      Stop(source, kVideoTrack); // XXX change to support multiple tracks    }    MOZ_ASSERT(mState == kStopped);  }  if (mState == kAllocated || mState == kStopped) {    Deallocate();  }  mViECapture = nullptr;  mViERender = nullptr;  mViEBase = nullptr;  mState = kReleased;  mInitDone = false;}

void	FSTCARingBuffer::AllocateWithABL(const AudioBufferList *abl)								// Assumes floating-point data{	Deallocate();		if(abl->mNumberBuffers == 0)		return;		UInt32 idx, byteSize = offsetof(AudioBufferList, mBuffers[0]) + (sizeof(AudioBuffer) * abl->mNumberBuffers);	mBufferList = (AudioBufferList *)malloc(byteSize);	memset(mBufferList, 0, byteSize);		mBufferList->mNumberBuffers = abl->mNumberBuffers;	for(idx=0; idx<mBufferList->mNumberBuffers; idx++)	{		mBufferList->mBuffers[idx].mNumberChannels = abl->mBuffers[idx].mNumberChannels;		mBufferList->mBuffers[idx].mDataByteSize = abl->mBuffers[idx].mDataByteSize;		mBufferList->mBuffers[idx].mData = malloc(mBufferList->mBuffers[idx].mDataByteSize);	}		mCapacityFrames = abl->mBuffers[0].mDataByteSize/abl->mBuffers[0].mNumberChannels/sizeof(float);		for (UInt32 i = 0; i<kFSTGeneralRingTimeBoundsQueueSize; ++i)	{		mTimeBoundsQueue[i].mStartTime = 0;		mTimeBoundsQueue[i].mEndTime = 0;		mTimeBoundsQueue[i].mUpdateCounter = 0;	}	mTimeBoundsQueuePtr = 0;}

voidMediaEngineGonkVideoSource::Shutdown(){  LOG((__FUNCTION__));  if (!mInitDone) {    return;  }  ReentrantMonitorAutoEnter sync(mCallbackMonitor);  if (mState == kStarted) {    SourceMediaStream *source;    bool empty;    while (1) {      {        MonitorAutoLock lock(mMonitor);        empty = mSources.IsEmpty();        if (empty) {          break;        }        source = mSources[0];      }      Stop(source, kVideoTrack); // XXX change to support multiple tracks    }    MOZ_ASSERT(mState == kStopped);  }  if (mState == kAllocated || mState == kStopped) {    Deallocate();  }  mState = kReleased;  mInitDone = false;}

bool tTexture::LoadImage(std::string filename) {	//This function uses the surface to load an image, then create a texture out of it	Deallocate();	//Create a "Guinna Pig" texture	SDL_Texture* thePig = NULL;	//Load a BMP into theSurface. BMP Is the only file type that native SDL2 can import. W(e will have to add SDL2_image to import other formats)	theSurface = SDL_LoadBMP(filename.c_str()); //SDL_LoadBMP expects a ( char[] )	//Debug VV	if(theSurface == NULL) {		std::cout << "Could not Load image! : " << SDL_GetError() <<std::endl;	} else {		//theTexture = SDL_CreateTextureFromSurface(theRenderer, theSurface);		thePig = SDL_CreateTextureFromSurface(theRenderer, theSurface);		//Debug VV		if(thePig == NULL) {			std::cout << "Could not create texture! : " << SDL_GetError() <<std::endl;		}		//Set the height and width. -> ->(Remember that theSurface is a pointer)		tWidth = theSurface->w;		tHeight = theSurface->h;		//We are going to recycle our global "Surface"		SDL_FreeSurface(theSurface);		theSurface = NULL;	}	//Here is where we copy thePig into sTexture: If anything went wrong, thePig would have been NULL	sTexture = thePig;	return sTexture != NULL;}

voidMediaEngineRemoteVideoSource::Shutdown(){  LOG((__PRETTY_FUNCTION__));  if (!mInitDone) {    return;  }  if (mState == kStarted) {    SourceMediaStream *source;    bool empty;    while (1) {      {        MonitorAutoLock lock(mMonitor);        empty = mSources.IsEmpty();        if (empty) {          MOZ_ASSERT(mPrincipalHandles.IsEmpty());          break;        }        source = mSources[0];      }      Stop(source, kVideoTrack); // XXX change to support multiple tracks    }    MOZ_ASSERT(mState == kStopped);  }  for (auto& registered : mRegisteredHandles) {    MOZ_ASSERT(mState == kAllocated || mState == kStopped);    Deallocate(registered.get());  }  MOZ_ASSERT(mState == kReleased);  Super::Shutdown();  mInitDone = false;}

void CMTDHistory::SetCoordinate(unsigned int id,                                const CSmallString& name,                                const CSmallString& type,                                double min_value,double max_value,unsigned int nbins){    if( Sizes == NULL ){        RUNTIME_ERROR("Sizes is NULL");    }    if( id < 0 || id >= NCoords ){        INVALID_ARGUMENT("id out-of-range");    }    if( nbins <= 0 ){        INVALID_ARGUMENT("nbins <= 0");    }    if( max_value < min_value ){        INVALID_ARGUMENT("max_value < min_value");    }    if(Buffers.NumOfMembers() > 0) {        // it was already finalized - destroy data        Deallocate();    }    Sizes[id].Type = type;    Sizes[id].Name = name;    Sizes[id].MinValue = min_value;    Sizes[id].MaxValue = max_value;    Sizes[id].NBins = nbins;    Sizes[id].BinWidth = (Sizes[id].MaxValue - Sizes[id].MinValue)/Sizes[id].NBins;    Sizes[id].Width = Sizes[id].MaxValue - Sizes[id].MinValue;}

void CMTDHistory::SetPVector(const CSimpleVector<double>& pvector){    unsigned int   curr_position = 0;    CMTDBuffer*    p_buff = NULL;    int            loc = 0;    Deallocate();    while(loc < pvector.GetLength()) {        if((p_buff == NULL) || (curr_position >= MaxBufferSize)) {            // allocate new buffer            p_buff = GetNewBuffer(MaxBufferSize);            curr_position = 0;        }        // now set height        p_buff->SetHeight(curr_position,pvector[loc++]);        for(unsigned int i=0; i < GetNumberOfCoords(); i++) {            // set value and width            p_buff->SetValue(curr_position,i,pvector[loc++]);            p_buff->SetWidth(curr_position,i,pvector[loc++]);        }        p_buff->IncNumberOfHills();        curr_position++;    }}

Vertex Centroid::Run(int width, int height, Vertices vertices) {  int required_bytes = sizeof(float) * width * height;  if (bytes_ < required_bytes) {    bytes_ = required_bytes;    for (int n = 0; n < 4; n++) {      if (buffer_[n] != NULL)        Deallocate((void*)buffer_[n]);      Allocate((void**)&(buffer_[n]), bytes_);    }  }  CentroidKernel(width, height, vertices, buffer_);  // Compute Centroid  Vertex center;  int count;  center.x = Reduce(width * height, buffer_[0]);  center.y = Reduce(width * height, buffer_[1]);  center.z = Reduce(width * height, buffer_[2]);  count = Reduce(width * height, buffer_[3]);  center.x /= count;  center.y /= count;  center.z /= count;  return center;}