`_CrtSetDbgFlag`

Article
08/03/2024

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

Syntaxe

int _CrtSetDbgFlag(
   int newFlag
);

Paramètres

newFlag
Nouvel état pour _crtDbgFlag.

Valeur retournée

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

Notes

La _CrtSetDbgFlag fonction permet à l’application de contrôler la façon dont le gestionnaire de tas de débogage suit les allocations de mémoire en modifiant les champs de bits de l’indicateur _crtDbgFlag . En définissant les champs de bits, l’application peut demander au gestionnaire de tas de débogage d’effectuer des opérations de débogage spéciales. Il existe plusieurs opérations possibles :

Vérification des fuites de mémoire lorsque l’application quitte et signale le cas échéant,
Simulant des conditions de mémoire faible en spécifiant que les blocs de mémoire libérés doivent rester dans la liste liée du tas,
Vérification de l’intégrité du tas en inspectant chaque bloc de mémoire à chaque demande d’allocation.

Quand _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. Étant donné que la définition des bits entraîne une augmentation de la sortie de diagnostic et une vitesse d’exécution de programme réduite, ces bits ne sont pas définis (désactivés) par défaut. Pour plus d’informations sur ces champs de bits, consultez les fonctions de création de rapports d’état de tas.

Champ de bits	Default	Description
`_CRTDBG_ALLOC_MEM_DF`	ACTIVÉ	ON : 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 : Ajoutez de nouvelles allocations à la liste liée du tas, mais définissez le type de bloc sur `_IGNORE_BLOCK`. Peuvent aussi être combinés avec n'importe quelle macro de contrôle de fréquence sur le tas.
`_CRTDBG_CHECK_ALWAYS_DF`	OFF	ON : Appelez `_CrtCheckMemory` à chaque demande d’allocation et de 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_DF`	OFF	ON : 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_DF`	OFF	ON : Conservez les blocs de mémoire libérés dans la liste liée du tas, attribuez-les au `_FREE_BLOCK` type et remplissez-les avec la valeur d’octet 0xDD. OFF : Ne conservez 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_DF`	OFF	ON : Effectuez une vérification automatique des fuites au moment de la sortie du programme via un appel et `_CrtDumpMemoryLeaks` générez un rapport d’erreurs si l’application n’a pas pu libérer toute la mémoire allouée. OFF : n’effectuez pas automatiquement la vérification des fuites à la sortie du programme. Peuvent aussi être combinés avec n'importe quelle macro de contrôle de fréquence sur le tas.

Macros de contrôle de fréquence sur le tas

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

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

Macro	Nombre , `mallocreallocfree`et `_msize` appels entre les appels à`_CrtCheckMemory`
`_CRTDBG_CHECK_EVERY_16_DF`	16
`_CRTDBG_CHECK_EVERY_128_DF`	128
`_CRTDBG_CHECK_EVERY_1024_DF`	1 024
`_CRTDBG_CHECK_DEFAULT_DF`	0 (par défaut, aucun contrôle du tas)

Par défaut, _CrtCheckMemory n’est pas appelé pendant les opérations de mémoire. Vous pouvez le modifier en envoyant les indicateurs indiqués ci-dessus._CrtSetDbgFlag()

Par exemple, vous pouvez spécifier une vérification du tas toutes les 16 malloc, reallocet free_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 frequency
    tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

    // Set the new bits
    _CrtSetDbgFlag(tmp);
}

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

newFlag est le nouvel état à appliquer et _crtDbgFlag 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

Appel _CrtSetDbgFlag égal newFlag pour _CRTDBG_REPORT_FLAG obtenir l’état actuel _crtDbgFlag et stocker la valeur retournée dans une variable temporaire.
Activez tous les bits par un « ou » au niveau du bit (|) de la variable temporaire avec les masques de bits correspondants (représentés dans le code de l’application par constantes manifestes).
Désactivez les autres bits avec un bit « et » (&) de la variable avec un bit « not » (~) des masques de bits appropriés.
Appel _CrtSetDbgFlag égal newFlag à 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 obtenir une vue d’ensemble de la gestion de la mémoire et du tas de débogage, consultez les détails du tas de débogage CRT.

Pour désactiver un indicateur avec la _CrtSetDbgFlag fonction, utilisez un « et » au niveau du bit (&) de la variable avec le bit « not » (~) du masque de bits.

Si newFlag elle n’est pas valide, cette fonction appelle le gestionnaire de paramètres non valide, comme décrit dans la validation des paramètres. 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.

Spécifications

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

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

Bibliothèques

Uniquement les versions de débogage des bibliothèques Runtime C.

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

Voir aussi

Routines de débogage
_crtDbgFlag
_CrtCheckMemory

Partager via