_ASSERT, , _ASSERTE_ASSERT_EXPR Macros

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

Syntaxe

// Typical usage:
_ASSERT_EXPR( booleanExpression, message );
_ASSERT( booleanExpression );
_ASSERTE( booleanExpression );

Paramètres

booleanExpression
Expression scalaire (expressions de pointeur comprises) évaluée à une valeur différente de zéro (true) ou égale à zéro (false).

message
Large chaîne à afficher dans le cadre du rapport.

Notes

Les macros _ASSERT_EXPR, _ASSERT et _ASSERTE offrent un mécanisme propre et simple pour vérifier des hypothèses pendant le processus de débogage d’une application. Ils sont flexibles, car ils n’ont pas besoin d’être placés dans #ifdef des instructions pour les empêcher d’être appelés dans une build de vente au détail d’une application. Cette flexibilité est obtenue à l’aide de la _DEBUG macro. _ASSERT_EXPR, _ASSERT et _ASSERTE sont disponibles uniquement lorsque _DEBUG est définie au moment de la compilation. Quand _DEBUG elle n’est pas définie, les appels à ces macros sont supprimés pendant le prétraitement.

_ASSERT_EXPR, _ASSERT et évaluent leur booleanExpression argument et _ASSERTE 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 _ASSERT macro imprime un message de diagnostic simple, _ASSERTE inclut une représentation sous forme de chaîne de l’expression ayant échoué dans le message et _ASSERT_EXPR inclut la message chaîne dans le message de diagnostic. Ces macros ne font rien lorsque booleanExpression a une valeur différente de zéro.

_ASSERT_EXPR, _ASSERT et _ASSERTE appellent _CrtDbgReportW, et toute la sortie est donc en caractères larges. _ASSERTE affiche correctement les caractères Unicode dans booleanExpression et _ASSERT_EXPR affiche les caractères Unicode dans message.

Étant donné que la macro _ASSERTE spécifie l’expression qui a échoué, et que _ASSERT_EXPR vous permet de spécifier un message dans le rapport généré, elles permettent aux utilisateurs d’identifier le problème sans faire référence au code source de l’application. Toutefois, l’inconvénient est que chaque message affiché par _ASSERT_EXPR et chaque expression évaluée par _ASSERTE sont inclus dans le fichier de sortie (version de débogage) de votre application sous forme de constante de chaîne. Par conséquent, si un grand nombre d’appels sont effectués à _ASSERT_EXPR ou _ASSERTE, ces expressions peuvent augmenter considérablement la taille de votre fichier de sortie.

Sauf indication contraire avec les fonctions et _CrtSetReportFile les _CrtSetReportMode messages apparaissent dans une boîte de dialogue contextuelle équivalente à la définition :

_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportW génère le rapport de débogage et détermine sa ou ses destinations, en fonction des modes de rapport actifs et du fichier de rapport défini pour le type de rapport _CRT_ASSERT . Par défaut, les erreurs et les échecs d’assertion sont dirigés vers une fenêtre de message de débogage. Les _CrtSetReportMode fonctions et _CrtSetReportFile les fonctions sont utilisées pour définir les destinations pour chaque type de rapport.

Lorsque la destination est une fenêtre de message de débogage et que l’utilisateur sélectionne le bouton Réessayer, retourne 1, _CrtDbgReportW ce qui provoque l’activation _ASSERT_EXPR_ASSERT des macros et _ASSERTE du débogueur si le débogage juste-à-temps (JIT) est activé.

Pour plus d’informations sur le processus de création de rapports, consultez la _CrtDbgReportfonction , _CrtDbgReportW Pour plus d’informations sur la résolution des échecs d’assertion et l’utilisation de ces macros comme mécanisme de gestion des erreurs de débogage, consultez Macros pour la création de rapports.

Outre les _ASSERT macros, la assert macro peut être utilisée pour vérifier la logique du programme. Cette macro est disponible dans les versions Debug et Release des bibliothèques. _RPTF Les _RPTmacros de débogage sont également disponibles pour générer un rapport de débogage, mais elles n’évaluent pas d’expression. Les macros _RPT génèrent un rapport simple. Les macros _RPTF incluent le fichier source et le numéro de la ligne où la macro de rapport a été appelée dans le rapport généré. Des versions à caractères larges de ces macros sont disponibles (_RPTW, _RPTFW). Les versions à caractères larges sont identiques aux versions à caractères étroits, sauf que des chaînes de caractères sont utilisées pour tous les paramètres de chaînes et la sortie.

Bien que _ASSERT_EXPR, _ASSERT et _ASSERTE sont des macros et sont disponibles en incluant <crtdbg.h>, l’application doit établir un lien avec une version de débogage de la bibliothèque runtime C quand elle _DEBUG est définie, car ces macros appellent d’autres fonctions d’exécution.

Spécifications

Macro	En-tête requis
_ASSERT_EXPR, _ASSERT, _ASSERTE	<crtdbg.h>

Exemple

Dans ce programme, des appels sont effectués aux macros _ASSERT et _ASSERTE pour tester la condition string1 == string2. Si la condition échoue, ces macros affichent un message de diagnostic. Le groupe de macros _RPT et _RPTF est également utilisé 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;
}

Use the assert macros to evaluate the expression p1 == p2.
crt_ASSERT_macro.c(54) :
Will _ASSERT find 'I am p1' == 'I am p2' ?
crt_ASSERT_macro.c(55) : Assertion failed!
crt_ASSERT_macro.c(58) :

Will _ASSERTE find 'I am p1' == 'I am p2' ?
crt_ASSERT_macro.c(59) : Assertion failed: p1 == p2
'I am p1' != 'I am p2'

Voir aussi

Routines de débogage
assertMacro, , _assert_wassert
_RPT, _RPTF, , _RPTFW_RPTWMacros