_CrtSetDbgFlag

 

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

Récupère ou modifie l’état de la _crtDbgFlag indicateur pour contrôler le comportement de répartition du Gestionnaire de tas de débogage (version debug uniquement).

  
      int _CrtSetDbgFlag(   
   int newFlag   
);  

Paramètres

newFlag
État de _crtDbgFlag.

Retourne l’état précédent de _crtDbgFlag.

Le _CrtSetDbgFlag fonction permet à l’application contrôler comment le Gestionnaire de tas de débogage effectue le suivi des allocations de mémoire en modifiant les champs de bits de le _crtDbgFlag indicateur. En définissant les bits (activation), l'application peut indiquer au gestionnaire de tas de débogage d'exécuter des opérations spécifiques de débogage, notamment la recherche de fuites de mémoire quand l'application s'arrête et la création de rapports si certaines sont détectées, la simulation de conditions de mémoire insuffisante en spécifiant que les blocs de mémoire libérés doivent rester dans la liste liée du tas, et la vérification de l'intégrité du tas en inspectant chaque bloc de mémoire lors de chaque demande d'allocation. Lors de la _DEBUG n’est pas défini, les appels à _CrtSetDbgFlag sont supprimés lors du prétraitement.

Le tableau suivant répertorie les champs de bits pour _crtDbgFlag et décrit leur comportement. Comme la définition des bits aboutit à une augmentation de la sortie des diagnostics et à une réduction de la vitesse d'exécution du programme, ces bits ne sont pas définis (désactivés) par défaut. Pour plus d’informations sur ces champs de bits, consultez fonctions de création de rapports l’état du tas.

Champ de bitsValeurDescription
_CRTDBG_ALLOC_MEM_DFONON : permet les allocations de tas de débogage et l'utilisation des identificateurs de type de bloc de mémoire, tels que _CLIENT_BLOCK. OFF : Ajoute les nouvelles allocations à la liste liée du tas, mais définissez type de bloc _IGNORE_BLOCK.

Peuvent aussi être combinés avec n'importe quelle macro de contrôle de fréquence sur le tas.
_CRTDBG_CHECK_ALWAYS_DFOFFON : Appelle _CrtCheckMemory à chaque demande d’allocation et désallocation. OFF : _CrtCheckMemory doit être appelé explicitement.

Les macros de contrôle de fréquence sur le tas n'ont aucun effet quand cet indicateur est défini.
_CRTDBG_CHECK_CRT_DFOFFON : inclut les types _CRT_BLOCK dans les opérations de détection des fuites et de différence d'état de mémoire. OFF : la mémoire utilisée en interne par la bibliothèque Runtime est ignorée par ces opérations.

Peuvent aussi être combinés avec n'importe quelle macro de contrôle de fréquence sur le tas.
_CRTDBG_DELAY_FREE_MEM_DFOFFON : Conserve liste liée du blocs dans le tas de mémoire libérés, leur assigne le _FREE_BLOCK type et les remplit avec la valeur d’octet 0xDD. OFF : ne conserve pas les blocs libérés dans la liste liée du tas.

Peuvent aussi être combinés avec n'importe quelle macro de contrôle de fréquence sur le tas.
_CRTDBG_LEAK_CHECK_DFOFFON : Exécute automatique de fuites à l’arrêt du programme via un appel à _CrtDumpMemoryLeaks et générer un rapport d’erreur si l’application n’a pas pu libérer toute la mémoire qu’elle a allouée. OFF : n'exécute pas automatiquement la recherche de fuites à la sortie du programme.

Peuvent aussi être combinés avec n'importe quelle macro de contrôle de fréquence sur le tas.

Les Macros de fréquence de vérification de tas

Vous pouvez spécifier la fréquence à laquelle la bibliothèque Runtime C effectue la validation du tas de débogage (_CrtCheckMemory) en fonction du nombre d’appels à malloc, realloc, libre, et _msize.

_CrtSetDbgFlag inspecte ensuite les 16 bits supérieurs du paramètre newFlag pour une valeur. La valeur spécifiée est le nombre de malloc, realloc, libre, et _msize appelle entre _CrtCheckMemory appels. Quatre macros prédéfinies sont fournies à cet effet.

MacroNombre d'appels à malloc, realloc, free et _msize entre les appels à _CrtCheckMemory
_CRTDBG_CHECK_EVERY_16_DF16
_CRTDBG_CHECK_EVERY_128_DF128
_CRTDBG_CHECK_EVERY_1024_DF1024
_CRTDBG_CHECK_DEFAULT_DF0 (par défaut, aucun contrôle du tas)

Par défaut, _CrtCheckMemory est appelée une fois toutes les 1 024 fois que vous appelez malloc, realloc, libre, et _msize.

Par exemple, vous pouvez spécifier un contrôle du tas toutes les 16 malloc, realloc, libre, et _msize des opérations avec le code suivant :

#include <crtdbg.h>  
int main( )  
{  
int tmp;  
  
// Get the current bits  
tmp = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);  
  
// Clear the upper 16 bits and OR in the desired freqency  
tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;  
  
// Set the new bits  
_CrtSetDbgFlag(tmp);  
}  

Les 16 bits supérieurs du paramètre newFlag sont ignorés quand _CRTDBG_CHECK_ALWAYS_DF est spécifié. Dans ce cas, _CrtCheckMemory est appelée chaque fois que vous appelez malloc, realloc, libre, et _msize.

newFlagest le nouvel état à appliquer à la _crtDbgFlag et est une combinaison des valeurs pour chacun des champs de bits.

Pour changer un ou plusieurs de ces champs de bits et créer un état pour l'indicateur

  1. Appelez _CrtSetDbgFlag avec newFlag égal à _CRTDBG_REPORT_FLAG pour obtenir des cours _crtDbgFlag d’état et stockez la valeur retournée dans une variable temporaire.

  2. Activez les bits par une opération OR sur la variable temporaire avec les masques de bits correspondants (représentés dans le code de l'application par des constantes manifestes).

  3. Désactivez les autres bits par AND- sur la variable avec une opération de bits pas de masques de bits appropriés.

  4. Appelez _CrtSetDbgFlag avec newFlag égale à la valeur stockée dans la variable temporaire pour définir l’état de _crtDbgFlag.

Le code suivant montre comment simuler des conditions de mémoire insuffisante en conservant les blocs de mémoire libérés dans la liste liée du tas et empêcher _CrtCheckMemory d'être appelé à chaque demande d'allocation :

// Get the current state of the flag  
// and store it in a temporary variable  
int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );  
  
// Turn On (OR) - Keep freed memory blocks in the  
// heap's linked list and mark them as freed  
tmpFlag |= _CRTDBG_DELAY_FREE_MEM_DF;  
  
// Turn Off (AND) - prevent _CrtCheckMemory from  
// being called at every allocation request  
tmpFlag &= ~_CRTDBG_CHECK_ALWAYS_DF;  
  
// Set the new state for the flag  
_CrtSetDbgFlag( tmpFlag );  

Pour une vue d’ensemble de la gestion de la mémoire et le tas de débogage, consultez détails du tas de débogage CRT.

Pour désactiver un indicateur avec la _CrtSetDbgFlag (fonction), vous devez AND la variable avec l’opérateur de bits pas de masque de bits.

Si newFlag n’est pas une valeur valide, cette fonction appelle le Gestionnaire de paramètre non valide, comme décrit dans Validation de paramètre. Si l'exécution est autorisée à se poursuivre, cette fonction affecte la valeur errno à EINVAL et retourne l'état précédent de _crtDbgFlag.

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

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

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

// crt_crtsetdflag.c  
// compile with: /c -D_DEBUG /MTd -Od -Zi -W3 /link -verbose:lib /debug  
/*  
 * This program concentrates on allocating and freeing memory  
 * blocks to test the functionality of the _crtDbgFlag flag..  
 */  
  
#include <string.h>  
#include <malloc.h>  
#include <crtdbg.h>  
  
int main( )  
{  
        char *p1, *p2;  
        int tmpDbgFlag;  
  
        _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );  
        _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );  
        /*  
         * Set the debug-heap flag to keep freed blocks in the  
         * heap's linked list - This will allow us to catch any  
         * inadvertent use of freed memory  
         */  
        tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);  
        tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;  
        tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;  
        _CrtSetDbgFlag(tmpDbgFlag);  
  
        /*  
         * Allocate 2 memory blocks and store a string in each  
         */  
        p1 = malloc( 34 );  
        p2 = malloc( 38 );  
        strcpy_s( p1, 34, "p1 points to a Normal allocation block" );  
        strcpy_s( p2, 38, "p2 points to a Client allocation block" );  
  
        /*  
         * Free both memory blocks  
         */  
        free( p2 );  
        free( p1 );  
  
        /*  
         * Set the debug-heap flag to no longer keep freed blocks in the  
         * heap's linked list and turn on Debug type allocations (CLIENT)  
         */  
        tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);  
        tmpDbgFlag |= _CRTDBG_ALLOC_MEM_DF;  
        tmpDbgFlag &= ~_CRTDBG_DELAY_FREE_MEM_DF;  
        _CrtSetDbgFlag(tmpDbgFlag);  
  
        /*  
         * Explicitly call _malloc_dbg to obtain the filename and   
         * line number of our allocation request and also so we can   
         * allocate CLIENT type blocks specifically for tracking  
         */  
        p1 = _malloc_dbg( 40, _NORMAL_BLOCK, __FILE__, __LINE__ );  
        p2 = _malloc_dbg( 40, _CLIENT_BLOCK, __FILE__, __LINE__ );  
        strcpy_s( p1, 40, "p1 points to a Normal allocation block" );  
        strcpy_s( p2, 40, "p2 points to a Client allocation block" );  
  
        /*  
         * _free_dbg must be called to free the CLIENT block  
         */  
        _free_dbg( p2, _CLIENT_BLOCK );  
        free( p1 );  
  
        /*  
         * Allocate p1 again and then exit - this will leave unfreed  
         * memory on the heap  
         */  
        p1 = malloc( 10 );  
}  

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

Routines de débogage
_crtDbgFlag
_CrtCheckMemory

Afficher: