_expand_dbg

 

Date de publication : août 2016

Pour obtenir la dernière documentation sur Visual Studio 2017, consultez Documentation Visual Studio 2017.

Redimensionne un bloc de mémoire dans le tas spécifié en développant ou en sous-traitance le bloc (version debug uniquement).

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

Paramètres

userData
Pointeur vers le bloc de mémoire précédemment alloué.

newSize
Nouvelle taille pour le bloc (en octets) demandée.

blockType
Type de bloc redimensionné demandé : _CLIENT_BLOCK ou _NORMAL_BLOCK.

filename
Pointeur vers le nom du fichier source qui a demandé développez opération ou NULL.

linenumber
Numéro de ligne dans le fichier source où l’opération d’extension a été demandée ou NULL.

Le filename et linenumber paramètres sont disponibles uniquement quand _expand_dbg a été appelée explicitement ou _CRTDBG_MAP_ALLOC constante du préprocesseur a été définie.

Opération réussie, _expand_dbg retourne un pointeur vers le bloc de mémoire redimensionnée. Étant donné que la mémoire n’est pas déplacée, l’adresse est identique à l’userData. Si une erreur s’est produite, ou le bloc n’a pas pu être développé à la taille demandée, il renvoie NULL. En cas de défaillance, errno avec des informations sur la nature de la défaillance du système d’exploitation. Pour plus d’informations sur errno, consultez errno, _doserrno, _sys_errlist et _sys_nerr.

Le _expand_dbg fonction est une version debug de le _développez (fonction). Lors de la _DEBUG n’est pas défini, chaque appel à _expand_dbg est réduit à un appel à _expand. Les deux _expand et _expand_dbg redimensionner un bloc de mémoire dans le tas de base, mais _expand_dbg gère plusieurs fonctionnalités de débogage : mémoires tampons de chaque côté de la partie utilisateur du bloc pour vérifier la présence de fuites, un paramètre de type de bloc pour effectuer le suivi des types d’allocation spécifiques et filename / linenumber plus d’informations pour déterminer l’origine des demandes d’allocation.

_expand_dbgRedimensionne le bloc de mémoire spécifié avec un peu plus d’espace que demandé newSize. newSize peut être inférieure ou supérieure à la taille du bloc de mémoire alloué initialement. L'espace supplémentaire est utilisé par le gestionnaire de tas de débogage pour lier les blocs de mémoire de débogage et pour fournir à l'application des informations sur les en-têtes de débogage et les mémoires tampons de remplacement. Le redimensionnement s’effectue en développant ou en sous-traitance le bloc de mémoire d’origine. _expand_dbgne déplace pas le bloc de mémoire, comme le fait le _realloc_dbg (fonction).

Lorsque newSize est supérieure au bloc d’origine la taille, le bloc de mémoire est développé. Lors d’une extension, si le bloc de mémoire ne peut pas être étendu pour prendre en compte la taille demandée, NULL est retourné. Lorsque newSize est inférieur au bloc d’origine la taille, le bloc de mémoire est contractée jusqu'à ce que la nouvelle taille est obtenue.

Pour plus d’informations sur la façon dont les blocs de mémoire sont alloués, initialisés et gérés dans la version de débogage du tas de base, voir CRT Debug Heap Details. Pour plus d’informations sur les types de blocs d’allocation et comment elles sont utilisées, consultez Types de bloc sur le tas de débogage. Pour plus d’informations sur les différences entre appeler une fonction de tas standard et sa version de débogage dans une version debug d’une application, consultez Versions Debug des tas d’Allocation fonctions.

Cette fonction valide ses paramètres. Si memblock est un pointeur null, ou si la taille est supérieure à _HEAP_MAXREQ, cette fonction appelle un gestionnaire de paramètre non valide, comme décrit dans Validation de paramètre. Si l'exécution est autorisée à se poursuivre, errno a la valeur EINVAL et la fonction retourne une valeur NULL.

RoutineEn-tête requis
_expand_dbg<crtdbg.h>

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Les versions Debug de les bibliothèques Runtime C uniquement.

// 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  

La sortie de ce programme dépend de la capacité de votre ordinateur pour développer toutes les sections. Si toutes les sections sont développées, la sortie est reflétée dans la section de sortie.

Non applicable. Pour appeler la fonction C standard, utilisez PInvoke. Pour plus d'informations, consultez Exemples d'appel de plateforme.

Routines de débogage
_malloc_dbg

Afficher: