_expand_dbg

Ridimensiona un blocco di memoria specificato nell'heap espandendo o contraendo il blocco (solo versione di debug).

Sintassi

void *_expand_dbg(
   void *userData,
   size_t newSize,
   int blockType,
   const char *filename,
   int lineNumber
);

Parametri

userData
Puntatore al blocco di memoria allocato precedentemente.

newSize
Nuove dimensioni richieste per il blocco, in byte.

blockType
Tipo di blocco ridimensionato richiesto: _CLIENT_BLOCK o _NORMAL_BLOCK.

filename
Puntatore al nome del file di origine che ha richiesto l'operazione di espansione oppure NULL.

lineNumber
Numero di riga nel file di origine in cui è stata richiesta l'operazione di espansione oppure NULL.

I filename parametri e lineNumber sono disponibili solo quando _expand_dbg è stato chiamato in modo esplicito o la costante del _CRTDBG_MAP_ALLOC preprocessore è stata definita.

Valore restituito

Al termine, _expand_dbg restituisce un puntatore al blocco di memoria ridimensionato. Poiché la memoria non viene spostata, l'indirizzo corrisponde a userData. Se si è verificato un errore o non è stato possibile espandere il blocco fino alle dimensioni richieste, restituisce NULL. Se si verifica un errore, viene restituito errno con le informazioni dal sistema operativo sulla natura dell'errore. Per altre informazioni su errno, vedere errno, _doserrno, _sys_errliste _sys_nerr.

Osservazioni:

La _expand_dbg funzione è una versione di debug della funzione _expand . Quando _DEBUG non è definito, ogni chiamata a _expand_dbg viene ridotta a una chiamata a _expand. Sia _expand che _expand_dbg ridimensionano un blocco di memoria nell'heap di base, ma _expand_dbg contiene diverse funzionalità di debug: buffer presenti a entrambi i lati della parte del blocco da verificare per le perdite, un parametro di tipo del blocco per registrare i tipi specifici di allocazioni e informazioni su filename/lineNumber per determinare l'origine delle richieste di allocazione.

_expand_dbg ridimensiona il blocco di memoria specificato con una quantità di spazio appena superiore al valore richiesto di newSize. newSize potrebbe essere maggiore o minore della dimensione del blocco di memoria allocato in origine. Lo spazio aggiuntivo viene usato dal gestore dell'heap di debug per collegare i blocchi di memoria di debug e per fornire all'applicazione informazioni sull'intestazione di debug e buffer di sovrascrittura. Il ridimensionamento viene eseguito espandendo o contraendo il blocco di memoria originale. _expand_dbg non sposta il blocco di memoria, come fa la _realloc_dbg funzione .

Quando newSize è maggiore del blocco originale, il blocco di memoria viene espanso. Durante un'espansione, se il blocco di memoria non può essere espanso per supportare le dimensioni richieste, NULL viene restituito . Quando newSize è inferiore alle dimensioni del blocco originale, il blocco di memoria viene contratto fino a ottenere le nuove dimensioni richieste.

Per informazioni sulla modalità di allocazione, inizializzazione e gestione dei blocchi di memoria nella versione di debug dell'heap di base, vedere Dettagli dell'heap di debug CRT. Per informazioni sui tipi di blocchi di allocazione e sul modo in cui vengono usati, vedere Tipi di blocchi nell'heap di debug. Per informazioni sulle differenze tra le funzioni heap standard e le versioni di debug, vedere Eseguire il debug delle versioni delle funzioni di allocazione dell'heap.

Questa funzione convalida i relativi parametri. Se userData è un puntatore Null o se size è maggiore di _HEAP_MAXREQ, questa funzione richiama un gestore di parametri non validi, come descritto in Convalida dei parametri. Se l'esecuzione può continuare, errno viene impostato su EINVAL e la funzione restituisce NULL.

Requisiti

Ciclo	Intestazione obbligatoria
_expand_dbg	<crtdbg.h>

Per altre informazioni sulla compatibilità, vedere Compatibility (Compatibilità).

Librerie

Solo le versioni di debug delle librerie di runtime di C.

Esempio

// crt_expand_dbg.c
//
// This program allocates a block of memory using _malloc_dbg
// and then calls _msize_dbg to display the size of that block.
// Next, it uses _expand_dbg to expand the amount of
// memory used by the buffer and then calls _msize_dbg again to
// display the new amount of memory allocated to the buffer.
//

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <crtdbg.h>

int main( void )
{
   long *buffer;
   size_t size;

   // Call _malloc_dbg to include the filename and line number
   // of our allocation request in the header
   buffer = (long *)_malloc_dbg( 40 * sizeof(long),
                                 _NORMAL_BLOCK, __FILE__, __LINE__ );
   if( buffer == NULL )
      exit( 1 );

   // Get the size of the buffer by calling _msize_dbg
   size = _msize_dbg( buffer, _NORMAL_BLOCK );
   printf( "Size of block after _malloc_dbg of 40 longs: %u\n", size );

   // Expand the buffer using _expand_dbg and show the new size
   buffer = (long *)_expand_dbg( buffer, size + sizeof(long),
                                 _NORMAL_BLOCK, __FILE__, __LINE__ );

   if( buffer == NULL )
      exit( 1 );
   size = _msize_dbg( buffer, _NORMAL_BLOCK );
   printf( "Size of block after _expand_dbg of 1 more long: %u\n",
           size );

   free( buffer );
   exit( 0 );
}

Size of block after _malloc_dbg of 40 longs: 160
Size of block after _expand_dbg of 1 more long: 164

Comment

L'output di questo programma dipende dalla capacità del computer di espandere tutte le sezioni. Se tutte le sezioni sono espanse, l'output è nella sezione Output.

Vedi anche

Routine di debug
_malloc_dbg