Exporter (0) Imprimer
Développer tout
and
div
eof
not
or
xor
Développer Réduire
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

_expand_dbg

Redimensionne un bloc de mémoire spécifié dans le tas en développant ou en contractant le bloc (version Debug uniquement).

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

userData

Pointeur du bloc de mémoire précédemment allouée.

newSize

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

blockType

Type demandé pour le bloc redimensionné : _CLIENT_BLOCK ou _NORMAL_BLOCK.

filename

Le pointeur du nom du fichier source qui a demandé l'opération de développement ou NULL.

linenumber

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

Les paramètres filename et linenumber sont uniquement disponibles si _expand_dbg a été appelé explicitement ou si la constante de préprocesseur _CRTDBG_MAP_ALLOC a été définie.

Lors d'une exécution réussie, _expand_dbg retourne un pointeur vers le bloc de mémoire redimensionné. Comme la mémoire n'est pas déplacée, l'adresse est identique à userData. Si une erreur se produit ou si le bloc n'a pas pu être développé à la taille demandée, il retourne NULL. Si une erreur se produit, errno fournit les informations du système d'exploitation sur la nature de l'échec. Pour plus d'informations sur errno, consultez errno, _doserrno, _sys_errlist et _sys_nerr.

La fonction _expand_dbg est une version Debug de la fonction _expand. Lorsque _DEBUG n'est pas défini, chaque appel à _expand_dbg est réduit à un appel à _expand. _expand et _expand_dbg redimensionnent un bloc de mémoire dans le tas de base, mais _expand_dbg s'adapte à plusieurs fonctionnalités de débogage : mémoires tampons de chaque côté de la partie utilisateur du bloc à déterminer des fuites, un paramètre de type de bloc pour suivre des types spécifiques d'allocation, et filename/linenumber pour déterminer l'origine des demandes d'allocation.

_expand_dbg redimensionne le bloc de mémoire spécifié avec légèrement plus d'espace que demandait newSize. newSize peut être supérieure ou inférieure à la taille du bloc de mémoire initialement alloué. L'espace supplémentaire est utilisé par le gestionnaire du tas de débogage pour lier les blocs de mémoire de débogage, pour fournir à l'application les informations d'en-tête du débogage et pour remplacer des mémoires tampons. Le redimensionnement est accompli en développant ou en contractant le bloc de mémoire d'origine. _expand_dbg ne déplace pas le bloc de mémoire comme le fait la fonction _realloc_dbg.

Lorsque newSize est supérieure à la taille des blocs d'origine, le bloc de mémoire est développé. Pendant une expansion, si le bloc de mémoire ne peut pas être développé pour s'adapter à la taille demandée, NULL est retourné. Lorsque newSize est inférieure à la taille des blocs d'origine, le bloc de mémoire est contracté jusqu'à ce que la nouvelle taille soit obtenue.

Pour obtenir des informations sur la façon dont les blocs de mémoire sont alloués, initialisés, et gérés dans la version Debug du tas de base, consultez Détails du tas de débogage CRT. Pour obtenir des informations sur les types de bloc d'allocation et leur utilisation, consultez Types de blocs sur le tas de débogage. Pour obtenir des informations sur les différences entre appeler une fonction standard du tas et sa version Debug dans une version debug d'une application, consultez Versions Debug des fonctions d'allocation du tas.

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 est défini à EINVAL et la fonction retourne NULL.

Routine

En-tête requis

_expand_dbg

<crtdbg.h>

Pour plus d'informations sur la compatibilité, consultez Compatibilité.

Bibliothèques

Seulement les versions debug des bibliothèques Runtime C.

// 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 );
}
La taille du bloc après le _malloc_dbg de 40 longs : 160
Taille de bloc après _expand_dbg de 1 plus long : 164

La sortie de ce programme dépend de la capacité de votre ordinateur à développer toutes les sections. Si toutes les sections sont développées, la sortie est renvoyé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.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft