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

void SelPrinter(HWND hDlg){  PRINTDLG pd;  ZeroMemory(&pd,sizeof(PRINTDLG));  pd.lStructSize = sizeof(PRINTDLG);  pd.hwndOwner = hDlg;  HGLOBAL hNewDevMode = NULL;  HGLOBAL hNewDevNames = NULL;  if(hDevMode != NULL && hDevNames != NULL){    int size = GetSizeOfDevMode(hDevMode);    hNewDevMode = GlobalAlloc(GHND,size);    GlobalCpy(hNewDevMode,hDevMode,size);    size = GetSizeOfDevNames(hDevNames);    hNewDevNames = GlobalAlloc(GHND,size);    GlobalCpy(hNewDevNames,hDevNames,size);  }  pd.hDevMode = hNewDevMode;  pd.hDevNames = hNewDevNames;  pd.Flags = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC |              PD_NOPAGENUMS | PD_NOSELECTION | PD_HIDEPRINTTOFILE;  pd.nCopies = GetCurrentPrinterCopies();  pd.nFromPage = 1;  pd.nToPage = 1;  pd.nMinPage = 1;  pd.nMaxPage = 1;  if(PrintDlg(&pd)){    if(hPrintDC != NULL){      DeleteDC(hPrintDC);    }    hPrintDC = pd.hDC;    int size = GetSizeOfDevMode(pd.hDevMode);    if(hDevMode != NULL){      GlobalReAlloc(hDevMode,size,0);    }else{      hDevMode = GlobalAlloc(GHND,size);    }    GlobalCpy(hDevMode,pd.hDevMode,size);        size = GetSizeOfDevNames(pd.hDevNames);    if(hDevNames != NULL){      GlobalReAlloc(hDevNames,size,0);    }else{      hDevNames = GlobalAlloc(GHND,size);    }    GlobalCpy(hDevNames,pd.hDevNames,size);  }  SetCurrentDirectoryToExePath();  if(pd.hDevMode != NULL){    GlobalFree(pd.hDevMode);  }  if(pd.hDevMode != NULL){    GlobalFree(pd.hDevMode);  }}

UBOOL AfoDetectResize    (LPAFODETECT_STR lpafoDetectStr){    // If there is no more room, ...    if (lpafoDetectStr->uLineStrCnt EQ lpafoDetectStr->uLineStrNxt)    {        HGLOBAL hGlbLineStr;        // Unlock the global memory handle so we may resize it        GlobalUnlock (lpafoDetectStr->hGlbLineStr);        // Reallocate the AFOLINE_STR        //   moving the old data to the new location, and        //   freeing the old global memory        hGlbLineStr =          GlobalReAlloc (lpafoDetectStr->hGlbLineStr,                          (lpafoDetectStr->uLineStrCnt + AFOLINESTR_INCR) * sizeof (AFOLINE_STR),                          GMEM_MOVEABLE);        // Check for error        if (hGlbLineStr EQ NULL)            return FALSE;        // Save (possibly new) handle        lpafoDetectStr->hGlbLineStr  = hGlbLineStr;        lpafoDetectStr->lpafoLineStr = GlobalLock (hGlbLineStr);        return TRUE;    } else        return TRUE;} // End AfoDetectResize

/*** * This method is part of the IStream interface. * * It will change the size of a stream. * * TODO: Switch from small blocks to big blocks and vice versa. * * See the documentation of IStream for more info. */static HRESULT WINAPI HGLOBALStreamImpl_SetSize(				     IStream*      iface,				     ULARGE_INTEGER  libNewSize)   /* [in] */{  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;  HGLOBAL supportHandle;  TRACE("(%p, %d)/n", iface, libNewSize.u.LowPart);  /*   * HighPart is ignored as shown in tests   */  if (This->streamSize.u.LowPart == libNewSize.u.LowPart)    return S_OK;  /*   * Re allocate the HGlobal to fit the new size of the stream.   */  supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);  if (supportHandle == 0)    return E_OUTOFMEMORY;  This->supportHandle = supportHandle;  This->streamSize.u.LowPart = libNewSize.u.LowPart;  return S_OK;}

long	UPSF::xxxx_To_UClr(	HGLOBAL&	hUniv,	long&			univSize,	long			natv,	void*			natvPtr,	long			natvLen)	{	univSize = sizeof(short)*3L;	if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))		return AUPSF_MEMORYERROR;	short*	univPtr = (short*)GlobalLock(hUniv);	if(!univPtr)		return AUPSF_MEMORYERROR;  long	retValue;	if(natv==AUPSF_NATV_RGBCOLOR)		{		if(natvLen != sizeof(COLORREF))			retValue = AUPSF_SIZEERROR;    else			retValue = RGBColor_To_UClr(univPtr, *(COLORREF*)natvPtr);    }	else		retValue = AUPSF_CANTCONVERT;	GlobalUnlock(hUniv);	return retValue;	}

static void add_message(const struct message *msg){    if (!sequence) {        sequence_size = 10;        sequence =            (struct message *) GlobalAlloc(GMEM_DISCARDABLE,                                           sequence_size *                                           sizeof(struct message));    }    if (sequence_cnt == sequence_size) {        sequence_size *= 2;        sequence =            (struct message *) GlobalReAlloc((char NEAR *) sequence,                                             sequence_size *                                             sizeof(struct message)                                             , GMEM_DISCARDABLE);    }    assert(sequence);    sequence[sequence_cnt].message = msg->message;    sequence[sequence_cnt].flags = msg->flags;    sequence[sequence_cnt].wParam = msg->wParam;    sequence[sequence_cnt].lParam = msg->lParam;    sequence_cnt++;}

/* * MemReAlloc - allocate some memory */void *MemReAlloc( void *ptr, unsigned size ){    void *x;#ifndef __OS2_PM__#if defined( DEBUGMEM )    GLOBALHANDLE        h;    h = GlobalHandle( FP_SEG( ptr ) );    GlobalUnlock( h );    x = GlobalLock( GlobalReAlloc( h, size, GMEM_ZEROINIT | GMEM_MOVEABLE ) );#else    x = realloc( ptr, size );#endif#else    x = realloc( ptr, size );#endif#if defined( WANT_MSGS )    if( x == NULL ) {        MessageBox( HWND_DESKTOP, "AUUGH, Null Pointer", "Memory Allocation",                    MB_OK | MB_ICONHAND | MB_SYSTEMMODAL );    }#endif    return( x );} /* MemReAlloc */

long	UPSF::xxxx_To_UFon(	HGLOBAL&	hUniv,	long&			univSize,	long			natv,	void*			natvPtr,	long			natvLen)	{	univSize = natvLen;	if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))		return AUPSF_MEMORYERROR;	long*	univPtr = (long*)GlobalLock(hUniv);	if(!univPtr)		return AUPSF_MEMORYERROR;	long	retValue = AUPSF_NOERROR;	if(natv==AUPSF_NATV_FONT)		{		// just store the font name--each platform will convert on import		// the attributes will be stored separately		hmemcpy(univPtr, natvPtr, natvLen);		}	else		retValue = AUPSF_CANTCONVERT;	GlobalUnlock(hUniv);	return retValue;	}

void SetHandleSize (Handle handle, size_t newSize){	Ptr p;	HANDLE hMem;	memError = noErr;	if (handle)	{		p = *handle;		if (p)		{			GlobalUnlockPtr (p);			hMem = GlobalReAlloc (GlobalPtrHandle (p), newSize, GHND);				if (hMem)				p = (Ptr)GlobalLock (hMem);			else				p = NULL;		} 		if (p)			*handle = p;		else			memError = memFullErr;	}	else		memError = memWZErr;}

/****************************************************************************** * This method is part of the ILockBytes interface. * * It will change the size of the byte array. * * See the documentation of ILockBytes for more info. */static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(      ILockBytes*     iface,      ULARGE_INTEGER  libNewSize)   /* [in] */{  HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;  HGLOBAL supportHandle;  /*   * As documented.   */  if (libNewSize.u.HighPart != 0)    return STG_E_INVALIDFUNCTION;  if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)    return S_OK;  /*   * Re allocate the HGlobal to fit the new size of the stream.   */  supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);  if (supportHandle == 0)    return STG_E_MEDIUMFULL;  This->supportHandle = supportHandle;  This->byteArraySize.u.LowPart = libNewSize.u.LowPart;  return S_OK;}

HANDLE AllocRoomForDIB(BITMAPINFOHEADER bi, HBITMAP hBitmap){    DWORD               dwLen;    HANDLE              hDIB;    HDC                 hDC;    LPBITMAPINFOHEADER  lpbi;    HANDLE              hTemp;    // Figure out the size needed to hold the BITMAPINFO structure    // (which includes the BITMAPINFOHEADER and the color table).    dwLen = bi.biSize + PaletteSize((LPSTR) &bi);    hDIB  = GlobalAlloc(GHND,dwLen);    // Check that DIB handle is valid    if (!hDIB)        return NULL;    // Set up the BITMAPINFOHEADER in the newly allocated global memory,    // then call GetDIBits() with lpBits = NULL to have it fill in the    // biSizeImage field for us.    lpbi  = (LPBITMAPINFOHEADER)GlobalLock(hDIB);    *lpbi = bi;    hDC   = GetDC(NULL);    GetDIBits(hDC, hBitmap, 0, (UINT) bi.biHeight, NULL, (LPBITMAPINFO)lpbi,            DIB_RGB_COLORS);    ReleaseDC(NULL, hDC);    // If the driver did not fill in the biSizeImage field,    // fill it in -- NOTE: this is a bug in the driver!        if (lpbi->biSizeImage == 0)        lpbi->biSizeImage = WIDTHBYTES((DWORD)lpbi->biWidth *                lpbi->biBitCount) * lpbi->biHeight;    // Get the size of the memory block we need    dwLen = lpbi->biSize + PaletteSize((LPSTR) &bi) + lpbi->biSizeImage;    // Unlock the memory block    GlobalUnlock(hDIB);    // ReAlloc the buffer big enough to hold all the bits     if (hTemp = GlobalReAlloc(hDIB,dwLen,0))        return hTemp;    else    {        // Else free memory block and return failure        GlobalFree(hDIB);        return NULL;    }}

//********************************************************************Handle MyReAlloc(Handle hMem,				uint32_t dwSize,				uint32_t dwFlag){	return CFIO_ReAlloc?		CFIO_ReAlloc(hMem, dwSize, dwFlag):		GlobalReAlloc(hMem, dwSize, dwFlag);}

BOOL My_GlobalReAlloc(){	HGLOBAL hMem=NULL;	SIZE_T dwBytes=NULL;	UINT uFlags=NULL;	HGLOBAL returnVal_Real = NULL;	HGLOBAL returnVal_Intercepted = NULL;	DWORD error_Real = 0;	DWORD error_Intercepted = 0;	__try{	disableInterception();	returnVal_Real = GlobalReAlloc (hMem,dwBytes,uFlags);	error_Real = GetLastError();	enableInterception();	returnVal_Intercepted = GlobalReAlloc (hMem,dwBytes,uFlags);	error_Intercepted = GetLastError();	}__except(puts("in filter"), 1){puts("exception caught");}	return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));}

static HGLOBAL gmem_realloc(HGLOBAL *hg, unsigned size){ HGLOBAL hn; if (hn = *hg? GlobalReAlloc(*hg, size, loGMEM_FLAG):               GlobalAlloc(loGMEM_FLAG, size)) *hg = hn;/* else   {    UL_WARNING((LOGID, "%!L gmem_alloc(%u) FAILED", size));   }*/ return hn;}

void CMenuSpawn::AddImageItem(const int idx, WORD cmd){	if (iImageItem == 0)		pImageItem = (ImageItem *) GlobalAlloc(GPTR, sizeof(ImageItem));	else		pImageItem = (ImageItem *) GlobalReAlloc((HGLOBAL) pImageItem, sizeof(ImageItem) * (iImageItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);		ASSERT(pImageItem);	pImageItem[iImageItem].iCmd = (int) cmd;	pImageItem[iImageItem].iImageIdx = idx;	iImageItem ++;}

tdata_t_TIFFrealloc(tdata_t p, tsize_t s){	void* pvTmp;	if ((pvTmp = GlobalReAlloc(p, s, 0)) == NULL) {		if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {			CopyMemory(pvTmp, p, GlobalSize(p));			GlobalFree(p);		}	}	return ((tdata_t)pvTmp);}

void* prim_globalReAlloc(HGLOBAL arg1,DWORD arg2,UINT arg3){ static struct {HsPtr res1;HsInt gc_failed;HsPtr gc_failstring;} gc_result;  HGLOBAL res1;int gc_failed;	       char* gc_failstring;  do {res1 = GlobalReAlloc(arg1, arg2, arg3);      if ((gc_failed = ( res1==NULL ))) {gc_failstring = ErrorWin("GlobalReAlloc") ;}      else {gc_failed = 0;}      gc_result.res1 = (HGLOBAL)(res1);      gc_result.gc_failed = gc_failed;      gc_result.gc_failstring = gc_failstring;            return(&gc_result);} while(0);}

static HGLOBAL get_rtf_text(ME_TextEditor *editor, const ME_Cursor *start, int nChars){    EDITSTREAM es;    ME_GlobalDestStruct gds;    gds.hData = GlobalAlloc(GMEM_MOVEABLE, 0);    gds.nLength = 0;    es.dwCookie = (DWORD_PTR)&gds;    es.pfnCallback = ME_AppendToHGLOBAL;    ME_StreamOutRange(editor, SF_RTF, start, nChars, &es);    GlobalReAlloc(gds.hData, gds.nLength+1, 0);    return gds.hData;}

void AddScriptCmdArgs(const TCHAR *arg){  g_sdata.script_cmd_args = GlobalReAlloc(g_sdata.script_cmd_args,    GlobalSize(g_sdata.script_cmd_args) + (lstrlen(arg) + 2/* quotes */ + 1 /* space */)*sizeof(TCHAR),    0);  TCHAR *args = (TCHAR *) GlobalLock(g_sdata.script_cmd_args);  lstrcat(args, _T(" /""));  lstrcat(args, arg);  lstrcat(args, _T("/""));  GlobalUnlock(g_sdata.script_cmd_args);}

void _fastcall ReAllocHGlobal(ParamBlk *parm){	HGLOBAL hMem;	hMem = GlobalReAlloc((HGLOBAL)p1.ev_long,(SIZE_T)p2.ev_long,GMEM_MOVEABLE|GMEM_ZEROINIT);	if (hMem)	{		REPLACEDEBUGALLOC(p1.ev_long,hMem,p2.ev_long);				RET_INTEGER(hMem);	}	else	{		SAVEWIN32ERROR(GlobalReAlloc,GetLastError());		RAISEERROREX(0);	}}

static HRESULT WINAPI NoStatStreamImpl_SetSize(				     IStream*      iface,				     ULARGE_INTEGER  libNewSize)   /* [in] */{  NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;  HGLOBAL supportHandle;  if (libNewSize.u.HighPart != 0)    return STG_E_INVALIDFUNCTION;  if (This->streamSize.u.LowPart == libNewSize.u.LowPart)    return S_OK;  supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);  if (supportHandle == 0)    return STG_E_MEDIUMFULL;  This->supportHandle = supportHandle;  This->streamSize.u.LowPart = libNewSize.u.LowPart;  return S_OK;}

voidIT_GLOBALREALLOC (ENV *envp,LONGPROC f)		/* GlobalReAlloc */{    UINT uiFlags, uSel;    HGLOBAL hGlobal;    LPBYTE  lpSeg;    WORD wSP=0,wBP=0;    DWORD dwNewSize;    uSel = GETWORD(SP+10) | 1;    uiFlags = (UINT)GETWORD(SP+4);    dwNewSize = GETDWORD(SP+6);    if (dwNewSize != 0) {#ifdef LATER	dwNewSize = max(dwNewSize,32);	dwNewSize = (dwNewSize + 31) & 0xffffffe0;#endif        	lpSeg = GetPhysicalAddress(uSel);	if (uSel == envp->reg.ss) {	    wSP = (WORD)(SP - lpSeg);	    wBP = (WORD)(BP - lpSeg);	}	uSel = TWIN_ReallocSelector(uSel,dwNewSize,uiFlags);	hGlobal = GetSelectorHandle(uSel);	if (uSel == envp->reg.ss) {	    envp->reg.sp = (REGISTER)(GetPhysicalAddress(uSel) + wSP);	    envp->reg.bp = (REGISTER)(GetPhysicalAddress(uSel) + wBP);	}	if (uiFlags & GMEM_MOVEABLE) {	    GlobalUnlock(hGlobal);	    uSel &= 0xfffe;	}    } else {	/* check if we are discarding, size 0,... */	hGlobal = GetSelectorHandle(uSel);	(void) GlobalReAlloc(hGlobal,0,uiFlags);    }    envp->reg.sp += HANDLE_86 + UINT_86 + DWORD_86 + RET_86;    envp->reg.ax = LOWORD(uSel);    envp->reg.dx = 0;}

LPBYTE DownloadToMemory(IN LPCTSTR lpszURL, OUT PDWORD_PTR lpSize){	LPBYTE lpszReturn = 0;	*lpSize = 0;	const HINTERNET hSession = InternetOpen(TEXT("GetGitHubRepositoryList"), INTERNET_OPEN_TYPE_PRECONFIG, 0, 0, INTERNET_FLAG_NO_COOKIES);	if (hSession)	{		URL_COMPONENTS uc = { 0 };		TCHAR HostName[MAX_PATH];		TCHAR UrlPath[MAX_PATH];		uc.dwStructSize = sizeof(uc);		uc.lpszHostName = HostName;		uc.lpszUrlPath = UrlPath;		uc.dwHostNameLength = MAX_PATH;		uc.dwUrlPathLength = MAX_PATH;		InternetCrackUrl(lpszURL, 0, 0, &uc);		const HINTERNET hConnection = InternetConnect(hSession, HostName, INTERNET_DEFAULT_HTTPS_PORT, 0, 0, INTERNET_SERVICE_HTTP, 0, 0);		if (hConnection)		{			const HINTERNET hRequest = HttpOpenRequest(hConnection, TEXT("GET"), UrlPath, 0, 0, 0, INTERNET_FLAG_SECURE | INTERNET_FLAG_RELOAD, 0);			if (hRequest)			{				HttpSendRequest(hRequest, 0, 0, 0, 0);				lpszReturn = (LPBYTE)GlobalAlloc(GMEM_FIXED, 1);				DWORD dwRead;				static BYTE szBuf[1024 * 4];				LPBYTE lpTmp;				for (;;)				{					if (!InternetReadFile(hRequest, szBuf, (DWORD)sizeof(szBuf), &dwRead) || !dwRead) break;					lpTmp = (LPBYTE)GlobalReAlloc(lpszReturn, (SIZE_T)(*lpSize + dwRead), GMEM_MOVEABLE);					if (lpTmp == NULL) break;					lpszReturn = lpTmp;					CopyMemory(lpszReturn + *lpSize, szBuf, dwRead);					*lpSize += dwRead;				}				InternetCloseHandle(hRequest);			}			InternetCloseHandle(hConnection);		}		InternetCloseHandle(hSession);	}	return lpszReturn;}

long	UPSF::xxxx_To_xxxx(	HGLOBAL&	hUniv,	long&			univSize,	void*			natvPtr,	long			natvLen)	{	univSize = natvLen;	if((hUniv = GlobalReAlloc(hUniv, natvLen, MEMFLAGS))==NULL)		return AUPSF_MEMORYERROR;	void*	univPtr = GlobalLock(hUniv);	if(!univPtr)		return AUPSF_MEMORYERROR;	hmemcpy(univPtr, natvPtr, natvLen);	GlobalUnlock(hUniv);	return AUPSF_NOERROR;	}

HGLOBALGlobalReAllocP(    HGLOBAL hglbMem,    DWORD   cbBytes,    UINT    fuFlags){   HGLOBAL hReturn;   DWORD   dwBeforeSize = 0;   DWORD   dwAfterSize  = 0;   // get size of block before re-alloc-ing it   dwBeforeSize = (DWORD) GlobalSize(hglbMem);   if (dwBeforeSize > 0)   {      // size was obtained OK so realloc the block      hReturn = GlobalReAlloc(hglbMem, cbBytes, fuFlags);      if (hReturn != NULL)      {         // memory was re alloc'd so get the new size         dwAfterSize = (DWORD) GlobalSize(hReturn);      }      else      {         // memory was not re-alloced so set after size to 0      }      if (pAppData != NULL)      {         // update call count         pAppData->dwReAllocCalls ++;         pAppData->dwApplicationBytes -= dwBeforeSize;         pAppData->dwApplicationBytes += dwAfterSize;      }   }   else   {      // unable to read memory size nothing has changed      // return original pointer      hReturn = hglbMem;   }   return hReturn;}

static DWORD CALLBACK ME_AppendToHGLOBAL(DWORD_PTR dwCookie, LPBYTE lpBuff, LONG cb, LONG *pcb){    ME_GlobalDestStruct *pData = (ME_GlobalDestStruct *)dwCookie;    int nMaxSize;    BYTE *pDest;    nMaxSize = GlobalSize(pData->hData);    if (pData->nLength+cb+1 >= cb) {        /* round up to 2^17 */        int nNewSize = (((nMaxSize+cb+1)|0x1FFFF)+1) & 0xFFFE0000;        pData->hData = GlobalReAlloc(pData->hData, nNewSize, 0);    }    pDest = GlobalLock(pData->hData);    memcpy(pDest + pData->nLength, lpBuff, cb);    pData->nLength += cb;    pDest[pData->nLength] = '/0';    GlobalUnlock(pData->hData);    *pcb = cb;    return 0;}

bool My_GlobalReAlloc(HGLOBAL ret, DWORD error){	HGLOBAL dwRet = 0;	////	dwRet = GlobalReAlloc(GlobalAlloc(GMEM_MOVEABLE, 2), 2, GMEM_MODIFY);	if (dwRet != ret)		goto FAILED;	if (!checkErrorCode(error))		goto FAILED;	uninterceptedPrint("GlobalReAlloc PASSED!/n");return TRUE;FAILED:	uninterceptedPrint("GlobalReAlloc FAILED!/n");	return FALSE;}