Delen via

_ASSERT, , _ASSERTE_ASSERT_EXPR Macro's

Evalueer een expressie en genereer een foutopsporingsrapport wanneer het resultaat is false (alleen foutopsporingsversie).

Syntaxis

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

Parameterwaarden

booleanExpression
Een scalaire expressie (inclusief aanwijzerexpressies) die resulteert in niet-nul (true) of 0 (false).

message
Een brede tekenreeks die moet worden weergegeven als onderdeel van het rapport.

Opmerkingen

De _ASSERT_EXPRen _ASSERT_ASSERTE macro's bieden een toepassing een schoon en eenvoudig mechanisme voor het controleren van veronderstellingen tijdens het foutopsporingsproces. Ze zijn flexibel omdat ze niet hoeven te worden ingesloten in #ifdef instructies om te voorkomen dat ze worden aangeroepen in een retail-build van een toepassing. Deze flexibiliteit wordt bereikt met behulp van de _DEBUG macro. _ASSERT_EXPRen _ASSERT_ASSERTE zijn alleen beschikbaar wanneer _DEBUG tijdens het compileren is gedefinieerd. Wanneer _DEBUG deze macro's niet zijn gedefinieerd, worden aanroepen naar deze macro's verwijderd tijdens het voorverwerken.

_ASSERT_EXPRen _ASSERT_ASSERTE evalueer hun booleanExpression argument en wanneer het resultaat (0) is false , drukken ze een diagnostisch bericht af en roepen _CrtDbgReportW ze aan om een foutopsporingsrapport te genereren. De _ASSERT macro drukt een eenvoudig diagnostisch bericht af, _ASSERTE bevat een tekenreeksweergave van de mislukte expressie in het bericht en _ASSERT_EXPR bevat de message tekenreeks in het diagnostische bericht. Deze macro's doen niets wanneer booleanExpression ze niet-nul worden geëvalueerd.

_ASSERT_EXPR _ASSERTE en _ASSERT roept _CrtDbgReportWaan, waardoor alle uitvoer in brede tekens wordt weergegeven. _ASSERTE Hiermee worden Unicode-tekens correct afgedrukt in booleanExpression en _ASSERT_EXPR worden Unicode-tekens afgedrukt in message.

Omdat de _ASSERTE macro de mislukte expressie opgeeft en _ASSERT_EXPR u een bericht kunt opgeven in het gegenereerde rapport, kunnen gebruikers het probleem identificeren zonder te verwijzen naar de broncode van de toepassing. Er bestaat echter een nadeel dat elke message afgedrukte door _ASSERT_EXPR en elke expressie die wordt _ASSERTE geëvalueerd, wordt opgenomen in het uitvoerbestand (foutopsporingsversie) van uw toepassing als een tekenreeksconstante. Als er daarom een groot aantal aanroepen naar of worden gedaan _ASSERT_EXPR_ASSERTE, kunnen deze expressies de grootte van uw uitvoerbestand aanzienlijk vergroten.

Tenzij u anders opgeeft met de _CrtSetReportMode en _CrtSetReportFile functies, worden berichten weergegeven in een pop-updialoogvenster dat gelijk is aan de instelling:

_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportW genereert het foutopsporingsrapport en bepaalt de bestemming of bestemmingen, op basis van de huidige rapportmodus of -modi en het bestand dat is gedefinieerd voor het _CRT_ASSERT rapporttype. Standaard worden assertiefouten en -fouten doorgestuurd naar een foutopsporingsberichtvenster. De _CrtSetReportMode en _CrtSetReportFile functies worden gebruikt om de bestemmingen voor elk rapporttype te definiëren.

Wanneer het doel een foutopsporingsberichtvenster is en de gebruiker de knop Opnieuw proberen selecteert, _CrtDbgReportW retourneert u 1, waardoor de _ASSERT_EXPRfoutopsporingsprogramma's _ASSERT worden _ASSERTE gestart en macro's het foutopsporingsprogramma starten als Just-In-Time-foutopsporing (JIT) is ingeschakeld.

Zie de _CrtDbgReportfunctie , _CrtDbgReportW voor meer informatie over het rapportageproces. Zie Macro's voor rapportage voor meer informatie over het oplossen van assertiefouten en het gebruik van deze macro's als foutopsporingsmechanisme.

Naast de _ASSERT macro's kan de assert macro worden gebruikt om programmalogica te verifiëren. Deze macro is beschikbaar in zowel de foutopsporings- als releaseversies van de bibliotheken. _RPTFDe_RPT macro's voor foutopsporing zijn ook beschikbaar voor het genereren van een foutopsporingsrapport, maar er wordt geen expressie geëvalueerd. De _RPT macro's genereren een eenvoudig rapport. De _RPTF macro's bevatten het bronbestand en het regelnummer waarin de rapportmacro is aangeroepen in het gegenereerde rapport. Brede tekenversies van deze macro's zijn beschikbaar (_RPTW, _RPTFW). De brede tekenversies zijn identiek aan de smalle tekenversies, behalve dat brede tekenreeksen worden gebruikt voor alle tekenreeksparameters en uitvoer.

Hoewel _ASSERT_EXPR, _ASSERT en macro's zijn en _ASSERTE beschikbaar zijn door het opnemen <crtdbg.h>, moet de toepassing een koppeling maken met een foutopsporingsversie van de C-runtimebibliotheek wanneer _DEBUG deze zijn gedefinieerd omdat deze macro's andere runtimefuncties aanroepen.

Requirements

Macroniveau Vereiste header
_ASSERT_EXPR, _ASSERT_ASSERTE <crtdbg.h>

Example

In dit programma worden aanroepen gedaan naar de _ASSERT en _ASSERTE macro's om de voorwaarde string1 == string2te testen. Als de voorwaarde mislukt, worden met deze macro's een diagnostisch bericht afgedrukt. De _RPT en _RPTF groep macro's wordt ook in dit programma gebruikt als alternatief voor de printf functie.

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

Zie ook

Fouten opsporen in routines
assert Macro, _assert, _wassert
_RPT, , , _RPTF_RPTW_RPTFW Macro's

  • Last updated on