_CrtSetDbgFlag

Article
03/26/2013

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.

Champ de bits	Par défaut	Description
_CRTDBG_ALLOC_MEM_DF	ON	SUR : Activez les allocations de tas de débogage et l'utilisation des identificateurs en forme de bloc de mémoire, tels qu' _CLIENT_BLOCK.OUTRE DE : Ajoutez les nouvelles allocations à la liste liée du tas, mais définissez en forme de bloc à _IGNORE_BLOCK. Peut également être combiné avec les macros l'une des de contrôle de tas- fréquence.
_CRTDBG_CHECK_ALWAYS_DF	OFF	SUR : Appel _CrtCheckMemory à chaque demande d'allocation et de désallocation.OUTRE DE : _CrtCheckMemory doit être appelé explicitement. Les macros de contrôle de Tas- fréquence n'ont aucun effet lorsque cette balise est définie.
_CRTDBG_CHECK_CRT_DF	OFF	SUR : Incluez _CRT_BLOCK dans les opérations de détection des fuites et de différence d'état de la mémoire.OUTRE DE : La mémoire utilisée en interne par la bibliothèque Runtime est ignorée par ces opérations. Peut également être combiné avec les macros l'une des de contrôle de tas- fréquence.
_CRTDBG_DELAY_FREE_MEM_DF	OFF	SUR : Keep a libéré les blocs de mémoire dans la liste liée du tas, leur assigne le type de _FREE_BLOCK, et le remplit de 0xDD valeur d'octet.OUTRE DE : Ne pas conserver les blocs libérés dans la liste liée du tas. Peut également être combiné avec les macros l'une des de contrôle de tas- fréquence.
_CRTDBG_LEAK_CHECK_DF	OFF	SUR : Exécutez la fuite automatique en activant à la sortie du programme via un appel à _CrtDumpMemoryLeaks et générer un rapport d'erreurs si l'application ne libérait pas toute la mémoire qu'elle a allouée.OUTRE DE : N'exécutez pas automatiquement la fuite vérification à la sortie du programme. Peut également être combiné avec les macros l'une des de contrôle de tas- fréquence.

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.

Macro	Le nombre de malloc, le realloc, libres, et _msize des appels entre les appels à _CrtCheckMemory
_CRTDBG_CHECK_EVERY_16_DF	16
_CRTDBG_CHECK_EVERY_128_DF	128
_CRTDBG_CHECK_EVERY_1024_DF	1024
_CRTDBG_CHECK_DEFAULT_DF	0 (par défaut, aucun contrôle du tas)

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

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.
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).
Désactivez les autres bits par AND- in la variable à l'aide de bits NOT des masques de bits appropriés.
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

Routine	En-tête requis
_CrtSetDbgFlag	<crtdbg.h>

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é.