Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

_ASSERT ; _ASSERTE de macros

Évaluez une expression et générer un rapport de débogage lorsque le résultat est False (version debug uniquement).

_ASSERT( 
   booleanExpression 
);
_ASSERTE( 
   booleanExpression 
);

booleanExpression

Expression (pointeurs) qui prend une valeur différente de zéro ou 0.

Les macros d' _ASSERT et d' _ASSERTE fournissent à une demande un mécanisme propre et facile d'activer des hypothèses pendant le processus de débogage. Ils sont très souples car ils n'ont pas besoin d'être placés dans les instructions d' #ifdef pour les empêcher d'être appelé dans une version commerciale d'une application. Cette souplesse est effectuée à l'aide de la macro de _DEBUG . _ASSERT et _ASSERTE sont uniquement disponibles si _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 d' booleanExpression et lorsque le résultat est false (0), ils impriment un message de diagnostic et appellent _CrtDbgReportW pour générer un rapport de débogage. La macro d' _ASSERT imprime un message de diagnostic simple, tandis que _ASSERTE inclut une représentation sous forme de chaîne de l'expression dans le message. Ces macros n'ont aucun effet lorsque booleanExpression prend une valeur différente de zéro.

_ASSERT et _ASSERTE appellent _CrtDbgReportW, ce qui entraîne être toute la sortie caractères larges, et _ASSERTE imprime correctement des caractères Unicode dans booleanExpression.

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

Sauf indication contraire avec _CrtSetReportMode et _CrtSetReportFile s'exécute, 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 des destinations, en fonction de le mode Rapport ou des modes et le fichier actuels définis pour l'état d' _CRT_ASSERT type. Par défaut, les échecs d'assertion et les erreurs sont dirigées vers une fenêtre de message de débogage. Les fonctions de _CrtSetReportMode et de _CrtSetReportFile sont utilisées pour définir des destinations pour chaque type de rapport.

Lorsque la destination est une fenêtre de messages de débogage et l'utilisateur clique sur le bouton de Réessayer , _CrtDbgReport ou _CrtDbgReportW retourne 1, rendant pour démarrer les macros d' _ASSERT et d' _ASSERTE le débogueur à condition que le débogage juste-à-temps (JIT) est activé.

Pour plus d'informations sur le processus de création de rapports, consultez la fonction de _CrtDbgReport, _CrtDbgReportW . Pour plus d'informations sur résoudre les problèmes d'assertion et utiliser ces macros comme un mécanisme de gestion des erreurs d'erreur de débogage, consultez À l'aide de les macros pour la vérification et la création de rapports.

Les macros de débogage de _RPT, _RPTF sont également disponibles pour générer un rapport de débogage, mais elles n'ont pas une expression. Les macros d' _RPT génèrent une condition simple. Les macros d' _RPTF incluent le fichier source et le numéro de ligne où la macro d'état a été appelée dans le rapport généré. Outre les macros d' _ASSERTE , la routine ANSI assertion peut être utilisée pour vérifier la logique de programme. Cette routine est disponible dans les versions debug et les bibliothèques. Les versions à caractère élargi de ces macros sont disponibles (_RPTWn, _RPTFWn). Les versions à caractères larges sont identiques aux versions étroites de caractère sauf que des chaînes à caractères larges sont utilisées pour tous les paramètres et de sortie de chaîne.

Bien qu' _ASSERT et _ASSERTE soient des macros et être obtenus en incluant Crtdbg.h, l'application doit être liée à l'une des bibliothèques suivantes car ces macros appellent d'autres fonctions runtime.

Libcmtd.lib

Bibliothèque statique multithread, version debug.

Msvcrtd.lib

bibliothèque d'importation pour Msvcr90d.dll, version debug.

Macro

en-tête requis

_ASSERT

<crtdbg.h>

_ASSERTE

<crtdbg.h>

Dans ce programme, les appels sont apportées aux macros d' _ASSERT et d' _ASSERTE pour tester la condition string1 == string2. si la condition échoue, ces macros impriment un message de diagnostic. Le groupe d' _RPTn et d' _RPTFn de macros est également testé dans ce programme, comme alternative à la fonction d' 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 == p2 de l'expression p1.  crt_ASSERT_macro.c (54) : 
 Le _ASSERT recherchera-il « i suis- » == p1 « que je suis p2 » ?  crt_ASSERT_macro.c (55) : Assertion a échoué !  crt_ASSERT_macro.c (58) : 

 Le _ASSERTE recherchera-il « i suis- » == p1 « que je suis p2 » ?  crt_ASSERT_macro.c (59) : Assertion a échoué : p1 == p2
« Je suis p1 » ! = « Je suis p2 »  

Ajouts de la communauté

AJOUTER
Afficher: