_CrtSetDbgFlag

Extrait ou modifie l'état de l'indicateur de _crtDbgFlag pour contrôler le comportement d'allocation du gestionnaire de tas de débogage (version debug uniquement).

int _CrtSetDbgFlag( 
   int newFlag 
);

Paramètres

• newFlag
  Nouvel état pour _crtDbgFlag.

Valeur de retour

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

Notes

La fonction d' _CrtSetDbgFlag permet à l'application de contrôler le gestionnaire de tas de débogage effectue le suivi des allocations de mémoire en modifiant les champs de bits de la balise de _crtDbgFlag .En définissant les bits (s'en activant), l'application peut indiquer au gestionnaire du tas de débogage exécuter des opérations spéciales de débogage, y compris la vérification des fuites de mémoire lorsque l'application se ferme et enregistrement si en sont détectés, simulant des conditions de mémoire insuffisante en spécifiant que les blocs de mémoire libérés doit rester la liste liée du tas, et en vérifiant l'état du tas en extrayant d'examiner chaque bloc de mémoire à chaque demande d'allocation.Lorsque _DEBUG n'est pas défini, les appels à _CrtSetDbgFlag sont supprimés pendant le prétraitement.

Le tableau suivant répertorie les champs de bits pour _crtDbgFlag et décrit leur comportement.Étant donné que la définition des résultats de bits dans la sortie de diagnostic augmentée et la vitesse d'exécution du programme réduite, ces bits ne sont pas définis (désactivé) par défaut.Pour plus d'informations sur ces champs de bits, consultez l' L'utilisation du tas de débogage.

Macros de la fréquence de Tas- contrôle

Vous pouvez spécifier la fréquence de la bibliothèque Runtime C exécute la validation du tas de débogage (_CrtCheckMemory) en fonction de le nombre d'appels à malloc, à realloc, à free, et à _msize.

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

Par défaut, _CrtCheckMemory est appelé une fois toutes les 1.024 fois que vous appelez malloc, realloc, free, et _msize.

Par exemple, vous pouvez spécifier un contrôle de tas chaque 16 malloc, realloc, free, et les opérations d' _msize par 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 d' newFlag sont ignorés lorsque le _CRTDBG_CHECK_ALWAYS_DF est spécifié.Dans ce cas, _CrtCheckMemory est appelé chaque fois que vous appelez malloc, realloc, free, et _msize.

newFlag est le nouvel état à appliquer à _crtDbgFlag et est une combinaison des valeurs pour les champs de bits.

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

1. Appelez _CrtSetDbgFlag avec newFlag égal à _CRTDBG_REPORT_FLAG pour obtenir l'état actuel de _crtDbgFlag et stocker la valeur retournée dans une variable temporaire.

2. Mettez à 1 tous les bits par OR- in la variable temporaire avec des masques de bits correspondants (représentés dans le code d'application par des constantes manifestes).

3. Désactivez les autres bits par AND- in la variable à l'aide de bits NOT des masques de bits appropriés.

4. Appel _CrtSetDbgFlag avec newFlag égale à la valeur stockée dans la variable temporaire pour définir le nouvel état pour _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 présentation de gestion de la mémoire et du tas de débogage, consultez l' Gestion de la mémoire et le tas de débogage.

Pour désactiver une balise avec la fonction d' _CrtSetDbgFlag, vous devez AND la variable à l'aide de bits NOT du masque de bits.

Si newFlag n'est pas une valeur valide, la fonction appelle le gestionnaire de paramètre non valide, comme décrit dans Validation des paramètres.Si est autorisé à l'exécution pour continuer, les jeux errno de cette fonction à EINVAL et retourne l'état précédent de _crtDbgFlag.

Configuration requise

Pour plus d'informations de compatibilité, consultez l' Compatibilité dans l'introduction.

Bibliothèques

Versions debug d' Bibliothèques runtime C uniquement.

Exemple

// 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 );
}

Équivalent .NET Framework

Non applicable. Pour appeler la fonction C standard, utilisez PInvoke. Pour plus d'informations, consultez l' Exemples d'appel de code non managé.

Voir aussi

Référence

Déboguez des routines

_crtDbgFlag

_CrtCheckMemory

Concepts

Fonctions de création de rapports sur l'état du tas