_ASSERT, _ASSERTE, _ASSERT_EXPR Makron

Utvärdera ett uttryck och generera en felsökningsrapport när resultatet är false (endast felsökningsversion).

Syntax

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

Parameterar

booleanExpression
Ett skalärt uttryck (inklusive pekaruttryck) som utvärderas till icke-zero (true) eller 0 (false).

message
En bred sträng som ska visas som en del av rapporten.

Anmärkningar

Makrona _ASSERT_EXPRoch _ASSERTE_ASSERT ger ett program en ren och enkel mekanism för att kontrollera antaganden under felsökningsprocessen. De är flexibla eftersom de inte behöver omges av #ifdef instruktioner för att förhindra att de anropas i en detaljhandelsversion av ett program. Den här flexibiliteten uppnås med hjälp av makrot _DEBUG . _ASSERT_EXPR, _ASSERT och _ASSERTE är endast tillgängliga när _DEBUG definieras vid kompileringstillfället. När _DEBUG inte har definierats tas anrop till dessa makron bort under förbearbetningen.

_ASSERT_EXPRoch _ASSERT_ASSERTE utvärderar deras booleanExpression argument och när resultatet är false (0) skriver de ut ett diagnostikmeddelande och anropar _CrtDbgReportW för att generera en felsökningsrapport. Makrot _ASSERT skriver ut ett enkelt diagnostikmeddelande, _ASSERTE innehåller en strängrepresentation av det misslyckade uttrycket i meddelandet och _ASSERT_EXPR innehåller strängen message i diagnostikmeddelandet. Dessa makron gör ingenting när booleanExpression utvärderas till nonzero.

_ASSERT_EXPR, _ASSERT och _ASSERTE anropar _CrtDbgReportW, vilket gör att alla utdata får breda tecken. _ASSERTE skriver ut Unicode-tecken korrekt i booleanExpression och _ASSERT_EXPR skriver ut Unicode-tecken i message.

Eftersom makrot _ASSERTE anger det misslyckade uttrycket och _ASSERT_EXPR låter dig ange ett meddelande i den genererade rapporten kan användarna identifiera problemet utan att referera till programmets källkod. Det finns dock en nackdel eftersom varje message skrivs ut av _ASSERT_EXPR och varje uttryck som utvärderas av _ASSERTE ingår i utdatafilen (felsökningsversionen) i ditt program som en strängkonstant. Om ett stort antal anrop görs till _ASSERT_EXPR eller _ASSERTEkan dessa uttryck därför avsevärt öka storleken på utdatafilen.

Om du inte anger något annat med _CrtSetReportMode funktionerna och _CrtSetReportFile visas meddelanden i en popup-dialogruta som motsvarar inställningen:

_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportW genererar felsökningsrapporten och avgör dess mål, baserat på det aktuella rapportläget eller lägena och filen som definierats för _CRT_ASSERT rapporttypen. Som standard dirigeras kontrollfel och fel till ett felsökningsmeddelandefönster. Funktionerna _CrtSetReportMode och _CrtSetReportFile används för att definiera mål för varje rapporttyp.

När målet är ett felsökningsmeddelandefönster och användaren väljer knappen Försök igen_CrtDbgReportW returnerar 1, vilket gör att makrona _ASSERT_EXPRoch _ASSERT_ASSERTE startar felsökningsprogrammet om JIT-felsökning (just-in-time) är aktiverat.

Mer information om rapporteringsprocessen finns i _CrtDbgReportfunktionen , _CrtDbgReportW . Mer information om hur du löser kontrollfel och använder dessa makron som en mekanism för felsökning av felhantering finns i Makron för rapportering.

Förutom makrona _ASSERT kan makrot assert användas för att verifiera programlogik. Det här makrot är tillgängligt i både felsöknings- och versionsversionerna av biblioteken. Felsökningsmakronen _RPT_RPTF är också tillgängliga för att generera en felsökningsrapport, men de utvärderar inte ett uttryck. Makrona _RPT genererar en enkel rapport. Makrona _RPTF innehåller källfilen och radnumret där rapportmakroten anropades i den genererade rapporten. Breda teckenversioner av dessa makron är tillgängliga (_RPTW, _RPTFW). De breda teckenversionerna är identiska med de smala teckenversionerna förutom att breda teckensträngar används för alla strängparametrar och utdata.

Även om _ASSERT_EXPR, _ASSERT och _ASSERTE är makron och är tillgängliga genom att inkludera <crtdbg.h>, måste programmet länka till en felsökningsversion av C-körningsbiblioteket när _DEBUG definieras eftersom dessa makron anropar andra körningsfunktioner.

Kravspecifikation

Example

I det här programmet görs anrop till makrona _ASSERT och _ASSERTE för att testa villkoret string1 == string2. Om villkoret misslyckas skriver makrona ut ett diagnostikmeddelande. Gruppen _RPT och _RPTF makron används också i det här programmet, som ett alternativ till printf funktionen.

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

Se även

Felsökningsrutiner
assert Makro, _assert, _wassert
_RPT, _RPTF, _RPTW, _RPTFW Makron