Exporter (0) Imprimer
Développer tout
div
eof
Développer Réduire
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

_CrtSetDbgFlag

Extrait ou modifie l'état de l'indicateur _crtDbgFlag pour contrôler le comportement d'allocation de la pile de débogage (version Debug uniquement).

int _CrtSetDbgFlag( 
   int newFlag 
);
newFlag

Nouvel état pour _crtDbgFlag.

Renvoie l'état précédent _crtDbgFlag.

La fonction _CrtSetDbgFlag permet à l'application de contrôler comment le gestionnaire du tas de débogage suit les allocations de mémoire en modifiant les champs de bits de l'indicateur _crtDbgFlag. En définissant les bits (si activation), l'application peut indiquer au gestionnaire du tas de débogage d'exécuter des opérations spécifiques de débogage, notamment examiner pour vérification des fuites de mémoire lorsque l'application s'arrête et le rapporter si certaines sont détectées, 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 accédant d'inspecter chaque bloc de mémoire à chaque demande d'allocation. Lorsque _DEBUG n'est pas défini, Les appels de _CrtSetDbgFlag sont supprimés pendant le prétraitement.

Le tableau suivant répertorie les champs de bits pour _crtDbgFlag et décrit leur comportement. Puisque définir les résultats de bits dans la sortie de diagnostic augmentée et la vitesse d'exécution du programme réduite, les bits ne sont pas définis (désactivé) par défaut. Pour plus d'informations sur les champs d'octets, consultez Détails du tas de débogage CRT.

Champ de bits

default

Description

_CRTDBG_ALLOC_MEM_DF

ON

ON : Vérifie les allocations de tas de débogage et l'utilisation des identificateurs de bloc de mémoire, tels que _CLIENT_BLOCK. OFF : Ajoute les nouvelles allocations dans la liste liée du tas, mais définir la valeur du 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_DF

OFF

ON : Appelle _CrtCheckMemory à chaque demande d'allocation et de libération. OFF : _CrtCheckMemory doit être appelé explicitement.

Les macros de contrôle de Tas- fréquence n'ont aucun effet lorsque cet indicateur est défini.

_CRTDBG_CHECK_CRT_DF

OFF

ON : Inclus 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 : Laisse libre les blocs de mémoire dans la liste liée du tas, leur assigne le type _FREE_BLOCK, et les rempli avec la valeur 0xDD d'octets. OFF : Ne laisse pas libre les blocs 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 : Exécute la vérification automatique de fuite à la sortie du programme via un appel à _CrtDumpMemoryLeaks et générer un rapport d'erreurs si l'application ne récupérait pas toute la mémoire qu'elle a allouée. OFF : N'exécute pas automatiquement la vérification de fuite à 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 fréquence de contrôle de Pile

Il est possible de spécifier la fréquence de l'exécution de la validation du tas de débogage par la bibliothèque Runtime C l(_CrtCheckMemory) selon le nombre d'appels à malloc, realloc, gratuit;free, 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, en realloc, gratuit, et d'appel de _msize entre les appels de _CrtCheckMemory. Quatre macros prédéfinies sont fournies à cet effet.

Macro

Nombre de malloc, de réallocations, 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, gratuit, et _msize.

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

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

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

  1. Appelez _CrtSetDbgFlag alors que le paramètre newFlag a la valeur _CRTDBG_REPORT_FLAG pour obtenir l'état actuel de _crtDbgFlag et stockez la valeur retournée dans une variable temporaire.

  2. Activez les bits en faisant une réunion logique OR (opérateur de bits de symbole |) de la variable temporaire et des masques de bits correspondants (représentés dans le code de l'application par des constantes manifestes).

  3. Désactivez les autres bits en faisant une intersection logique ET de la variable avec un opérateur de bits de symbole NON des masques de bits appropriés.

  4. Appelez _CrtSetDbgFlag alors que le paramètre newFlag a la valeur stockée dans la variable temporaire afin de créer 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 présentation de gestion de la mémoire et de la pile de débogage, consultez Détails du tas de débogage CRT.

Pour désactiver un indicateur avec la fonction _CrtSetDbgFlag, vous devez AND la variable avec les bits NOT du 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, la fonction renvoie -1 et définit errno avec la valeur EINVAL et renvoie l'état précédent de _crtDbgFlag.

Routine

En-tête requis

_CrtSetDbgFlag

<crtdbg.h>

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

Bibliothèques

Seulement les versions debug des bibliothèques Runtime C.

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

Référence

Autres ressources

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

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft. Tous droits réservés.