Exporter (0) Imprimer
Développer tout
and
div
eof
not
or
xor
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

_ASSERT, _ASSERTE, macros

Évalue une expression et génére un rapport de déboggage quand le résultat est False (version de débogage uniquement).

_ASSERT( 
   booleanExpression 
);
_ASSERTE( 
   booleanExpression 
);

booleanExpression

Expression (pointeurs compris) qui s'évalue à une valeur non nulle ou 0.

Les macros _ASSERT et _ASSERTE fournit à une application un méchanisme simple t propre pour vérifier les assomprions pendant le processus de déboggage. Elles sont extrêmement flexibles car elles n'ont pas besoin d'être enfermées entre les instructions #ifdef pour les empêcher d'être appelées dans une version commerciale d'une application. Cette flexibilité est réalisée à l'aide de la macro _DEBUG. _ASSERT et _ASSERTE sont disponibles uniquement lorsque _DEBUG est défini. Lorsque _DEBUG n'est pas défini, les appels à ces macros sont supprimés pendant le prétraitement.

_ASSERT et _ASSERTE évaluent leur argument booleanExpression et lorsque le résultat est false (0), elles envoient un message de diagnostic et appellent _CrtDbgReportW pour générer un rapport de déboggage. La macro _ASSERT envoie un message de diagnostic simple, tandis que _ASSERTE inclut une représentation de chaîne de l'expression non réussie dans le message. Les macros ne font rien lorsque booleanExpression prend une valeur différente de zéro.

_ASSERT et _ASSERTE appellent _CrtDbgReportW, ce qui force toutes les sorties à etre en caractères larges, et _ASSERTE imprime correctement les caractères Unicode dans booleanExpression.

Étant donné que la macro _ASSERTE spécifie l'expression dans le rapport généré, cela permet aux utilisateurs d'identifier le problème sans faire référence au code source de l'application. Toutefois, un inconvénient existe car chaque expression évaluée par _ASSERTE est incluse dans le fichier de sortie (version de débogage) de votre application comme une constante de chaîne. Par conséquent, si un grand nombre d'appels sont effectués par_ASSERTE, ces expressions peuvent augmenter considérablement la taille de votre fichier de sortie.

Sauf si vous spécifiez autrement avec les fonctions _CrtSetReportMode et _CrtSetReportFile , les messages apparaissent dans une boîte de dialogue contextuelle équivalente à définir :

_CrtSetReportMode(CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReport ou _CrtDbgReportW génère le rapport de débogage et détermine sa destination ou les destinations, basées sur le mode rapport actuel ou les modes et les fichier définis pour le rapport de type_CRT_ASSERT . Par défaut, les échecs d'assertion et les erreurs sont redirigées à une fenetre comportant un message de débogage. Les fonctions _CrtSetReportMode et _CrtSetReportFile sont utilisées pour définir les destinations de chaque type de rapport.

Lorsque la destination est une fenêtre comportant un message de débogage et l'utilisateur clique sur le bouton Réessayer, _CrtDbgReport ou _CrtDbgReportW retourne 1, ce qui force les macros _ASSERT et _ASSERTE à démarrer le débogueur si le débogage (JIT) est armé.

Pour plus d'informations sur le processus de création de rapports, consultez la fonction _CrtDbgReport, _CrtDbgReportW. Pour plus d'informations sur la résolution des problèmes d'assertion et l'utilisationde ces macros comme mécanisme de gestion d'erreur de débogage, consultez Utilisation de macros pour la vérification et la création de rapports.

Les macros de débogage _RPT, _RPTF sont également disponibles pour générer un rapport de débogage, mais elles n'évaluent pas une expression. Les macros _RPT générent un rapport simple. Les macros _RPTF incluent le fichier source et le numéro de ligne où le rapport de la macro a été appelée dans le rapport généré. En addition aux macros_ASSERTE, la routine ANSI assert peut être utilisé pour vérifier la logique de programme. Cette routine est disponible à la fois dans les versions normales et de débogage des librairies. Les versions en caractères larges des macros sont disponibles (_RPTWn, _RPTFWn). Les versions en caractères larges sont identiques à leurs homologues en caractères normaux sauf que des chaines de caractères larges sont utilisées pour tous les paramètres de chaines et les sorties

Bien que _ASSERT et _ASSERTE soient des macros et soient obtenues en incluant Crtdbg.h, l'application doit se lier avec l'une des bibliothèques suivantes car les macros appellent d'autres fonctions run-time.

Libcmtd.lib

Bibliothèque statique multithread, version de débogage.

Msvcrtd.lib

Bibliothèque importée pour Msvcr90d.dll, version de débogage.

Macro

En-tête requis

_ASSERT

<crtdbg.h>

_ASSERTE

<crtdbg.h>

Dans ce programme, les appels sont effectués aux macros d'_ASSERT et _ASSERTE pour tester la condition string1 == string2. Si la condition échoue, ces macros envoient un message de diagnostic. Les groupe de macros _RPTn et _RPTFn sont également utilisés dans ce programme, comme alternative à la fonction printf.

// crt_ASSERT_macro.c
// compile with: /D_DEBUG /MTd /Od /Zi /link /verbose:lib /debug
//
// This program uses the _ASSERT and _ASSERTE debugging macros.
//

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <crtdbg.h>

int main()
{
   char *p1, *p2;

   // The Reporting Mode and File must be specified
   // before generating a debug report via an assert
   // or report macro.
   // This program sends all report types to STDOUT.
   _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
   _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);
   _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
   _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDOUT);
   _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
   _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDOUT);

   // Allocate and assign the pointer variables.
   p1 = (char *)malloc(10);
   strcpy_s(p1, 10, "I am p1");
   p2 = (char *)malloc(10);
   strcpy_s(p2, 10, "I am p2");

   // Use the report macros as a debugging
   // warning mechanism, similar to printf.
   // Use the assert macros to check if the 
   // p1 and p2 variables are equivalent.
   // If the expression fails, _ASSERTE will
   // include a string representation of the
   // failed expression in the report.
   // _ASSERT does not include the
   // expression in the generated report.
   _RPT0(_CRT_WARN,
       "Use the assert macros to evaluate the expression p1 == p2.\n");
   _RPTF2(_CRT_WARN, "\n Will _ASSERT find '%s' == '%s' ?\n", p1, p2);
   _ASSERT(p1 == p2);

   _RPTF2(_CRT_WARN, "\n\n Will _ASSERTE find '%s' == '%s' ?\n",
          p1, p2);
   _ASSERTE(p1 == p2);

   _RPT2(_CRT_ERROR, "'%s' != '%s'\n", p1, p2);

   free(p2);
   free(p1);

   return 0;
}
Utilisez les macros d'assertion pour évaluer l'expression p1==p2.
crt_ASSERT_macro.c (54) : 
 _ASSERT trouvera t'il si 'Je suis p1'=='Je suis p2' ?
crt_ASSERT_macro.c (55) : L'assertion a échoué !
crt_ASSERT_macro.c (58) : 

 _ASSERT trouvera t'il si 'Je suis p1'=='Je suis p2' ?
crt_ASSERT_macro.c (59) : L'assertion a échoué : p1 == p2
'Je suis p1' != 'Je suis p2'

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft