_ASSERT-, _ASSERTE-, _ASSERT_EXPR-Makros_ASSERT, _ASSERTE, _ASSERT_EXPR Macros

Wertet einen Ausdruck aus und generiert einen Debugbericht, wenn das Ergebnis " false " ist (nur Debugversion).Evaluate an expression and generate a debug report when the result is False (debug version only).

SyntaxSyntax

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

ParameterParameters

booleanExpressionbooleanExpression
Ein skalarer Ausdruck (einschließlich Zeigerausdrücken) der zu ungleich null (true) oder „0“ (false) ausgewertet wird.A scalar expression (including pointer expressions) that evaluates to nonzero (true) or 0 (false).

Nachrichtmessage
Eine Breitzeichenfolge, die als Teil des Berichts angezeigt werden soll.A wide string to display as part of the report.

BemerkungenRemarks

Die Makros _ASSERT_EXPR, _ASSERT und _ASSERTE stellen eine Anwendung mit einem sauberen und einfachen Mechanismus für die Überprüfung von Annahmen während des Debugprozesses bereit.The _ASSERT_EXPR, _ASSERT and _ASSERTE macros provide an application with a clean and simple mechanism for checking assumptions during the debugging process. Sie sind sehr flexibel, da sie nicht in #ifdef -Anweisungen eingeschlossen werden müssen, um ihren Aufruf in der Verkaufsversion einer Anwendung zu verhindern.They are very flexible because they do not need to be enclosed in #ifdef statements to prevent them from being called in a retail build of an application. Diese Flexibilität wird mithilfe des _DEBUG -Makros erreicht.This flexibility is achieved by using the _DEBUG macro. _ASSERT_EXPR, _ASSERT und _ASSERTE sind nur verfügbar, wenn _DEBUG zum Zeitpunkt der Kompilierung definiert ist._ASSERT_EXPR, _ASSERT and _ASSERTE are only available when _DEBUG is defined at compile time. Wenn _DEBUG nicht definiert ist, werden Aufrufe dieser Makros während der Vorverarbeitung entfernt.When _DEBUG is not defined, calls to these macros are removed during preprocessing.

_ASSERT_EXPR, _ASSERT und _ASSERTE Ihr booleanExpression -Argument auswerten, und wenn das Ergebnis false (0) ist, wird eine Diagnose Meldung ausgegeben, und es wird _CrtDbgReportW aufgerufen, um einen Debugbericht zu generieren._ASSERT_EXPR, _ASSERT and _ASSERTE evaluate their booleanExpression argument and when the result is false (0), they print a diagnostic message and call _CrtDbgReportW to generate a debug report. Das _ASSERT -Makro druckt eine einfache Diagnose Meldung, _ASSERTE eine Zeichen folgen Darstellung des fehlgeschlagenen Ausdrucks in der Nachricht enthält, und _ASSERT_EXPR enthält die Meldungs Zeichenfolge in der Diagnose Meldung.The _ASSERT macro prints a simple diagnostic message, _ASSERTE includes a string representation of the failed expression in the message, and _ASSERT_EXPR includes the message string in the diagnostic message. Diese Makros führen keine Aktion aus, wenn booleanExpression als ungleich NULL ausgewertet wird.These macros do nothing when booleanExpression evaluates to nonzero.

_ASSERT_EXPR, _ASSERT und _ASSERTE _CrtDbgReportWaufrufen. Dies bewirkt, dass die gesamte Ausgabe in breit Zeichen ist._ASSERT_EXPR, _ASSERT and _ASSERTE invoke _CrtDbgReportW, which causes all output to be in wide characters. _ASSERTE gibt Unicode-Zeichen in booleanExpression ordnungsgemäß aus, und _ASSERT_EXPR gibt Unicode-Zeichen in der Nachrichtaus._ASSERTE properly prints Unicode characters in booleanExpression and _ASSERT_EXPR prints Unicode characters in message.

Da das _ASSERTE -Makro den fehlgeschlagenen Ausdruck angibt und _ASSERT_EXPR es Ihnen ermöglicht, eine Nachricht im generierten Bericht anzugeben, können Benutzer das Problem identifizieren, ohne auf den Quellcode der Anwendung zu verweisen.Because the _ASSERTE macro specifies the failed expression, and _ASSERT_EXPR lets you specify a message in the generated report, they enable users to identify the problem without referring to the application source code. Ein Nachteil besteht jedoch darin, dass jede von _ASSERT_EXPR gedruckte Nachricht und jeder von _ASSERTE ausgewertete Ausdruck in der Ausgabedatei (Debugversion) Ihrer Anwendung als Zeichen folgen Konstante enthalten ist.However, a disadvantage exists in that every message printed by _ASSERT_EXPR and every expression evaluated by _ASSERTE is included in the output (debug version) file of your application as a string constant. Wenn also eine große Anzahl von Aufrufen an _ASSERT_EXPR oder _ASSERTEvorgenommen wird, können diese Ausdrücke die Größe der Ausgabedatei erheblich vergrößern.Therefore, if a large number of calls are made to _ASSERT_EXPR or _ASSERTE, these expressions can greatly increase the size of your output file.

Sofern Sie es nicht mithilfe der Funktionen _CrtSetReportMode und _CrtSetReportFile anders festlegen, werden Meldungen in einem Popupdialogfeld angezeigt, entsprechend der Einstellung:Unless you specify otherwise with the _CrtSetReportMode and _CrtSetReportFile functions, messages appear in a pop-up dialog box equivalent to setting:

_CrtSetReportMode(CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportW generiert den Debugbericht und bestimmt sein Ziel oder seine Ziele basierend auf dem aktuellen Berichtsmodus oder den Modi und Dateien, die für den _CRT_ASSERT Berichtstyp definiert sind._CrtDbgReportW generates the debug report and determines its destination or destinations, based on the current report mode or modes and file defined for the _CRT_ASSERT report type. Standardmäßig werden Assertionsfehler und Fehler an ein Debugmeldungsfenster geleitet.By default, assertion failures and errors are directed to a debug message window. Die Funktionen _CrtSetReportMode und _CrtSetReportFile werden verwendet, um die Ziele für jeden Berichtstyp zu definieren.The _CrtSetReportMode and _CrtSetReportFile functions are used to define the destinations for each report type.

Wenn das Ziel ein debugmeldungsfenster ist und der Benutzer auf die Schaltfläche wiederholen klickt, gibt _CrtDbgReportW 1 zurück, wodurch die _ASSERT_EXPR, _ASSERT und _ASSERTE Makros den Debugger starten, vorausgesetzt, dass just-in-time (JIT)-Debugging aktiviert ist.When the destination is a debug message window and the user clicks the Retry button, _CrtDbgReportW returns 1, causing the _ASSERT_EXPR, _ASSERT and _ASSERTE macros to start the debugger provided that just-in-time (JIT) debugging is enabled.

Weitere Informationen zum Berichtstellungsverfahren finden Sie bei der Funktion _CrtDbgReport, _CrtDbgReportW .For more information about the reporting process, see the _CrtDbgReport, _CrtDbgReportW function. Weitere Informationen zum Beheben von Assertionsfehlern und zum Verwenden dieser Makros als Behandlungsmechanismus für Debugfehler finden Sie unter Verwenden von Makros zur Überprüfung und Berichterstellung.For more information about resolving assertion failures and using these macros as a debugging error handling mechanism, see Using Macros for Verification and Reporting.

Zusätzlich zu den _ASSERT Makros kann das Assert -Makro zum Überprüfen der Programmlogik verwendet werden.In addition to the _ASSERT macros, the assert macro can be used to verify program logic. Dieses Makro steht sowohl in der Debug- als auch in der endgültigen Version der Bibliotheken zur Verfügung.This macro is available in both the debug and release versions of the libraries. Die Debugmakros _RPT, _RPTF sind ebenfalls für die Erstellung eines Debugberichts verfügbar, werten aber keinen Ausdruck aus.The _RPT, _RPTF debug macros are also available for generating a debug report, but they do not evaluate an expression. Die _RPT -Makros generieren einen einfachen Bericht.The _RPT macros generate a simple report. Die _RPTF -Makros enthalten die Quelldatei und die Zeilennummer, in der das Berichts Makro im generierten Bericht aufgerufen wurde.The _RPTF macros include the source file and line number where the report macro was called in the generated report. Breit Zeichen Versionen dieser Makros sind verfügbar ( _RPTW _RPTFW).Wide character versions of these macros are available (_RPTW, _RPTFW). Die Breitzeichenversionen sind mit den Versionen mit schmalen Zeichen identisch, mit dem Unterschied, dass für alle Zeichenfolgenparameter und Ausgaben Breitzeichen-Zeichenfolgen verwendet werden.The wide character versions are identical to the narrow character versions except that wide character strings are used for all string parameters and output.

Obwohl _ASSERT_EXPR, _ASSERT und _ASSERTE Makros sind und verfügbar sind, indem Sie <Crtdbg. h-> einschließen, muss die Anwendung mit einer Debugversion der C-Lauf Zeit Bibliothek verknüpft werden, wenn _DEBUG definiert ist, da diese Makros andere Lauf Zeitfunktionen aufzurufen.Although _ASSERT_EXPR, _ASSERT and _ASSERTE are macros and are available by including <crtdbg.h>, the application must link with a debug version of the C run-time library when _DEBUG is defined because these macros call other run-time functions.

Requirements (Anforderungen)Requirements

MakroMacro Erforderlicher HeaderRequired header
_ASSERT_EXPR, _ASSERT _ASSERTE_ASSERT_EXPR, _ASSERT, _ASSERTE <crtdbg.h><crtdbg.h>

BeispielExample

In diesem Programm werden Aufrufe an die _ASSERT -und _ASSERTE -Makros durchgeführt, um die Bedingung string1 == string2zu testen.In this program, calls are made to the _ASSERT and _ASSERTE macros to test the condition string1 == string2. Wenn bei der Bedingung ein Fehler auftritt, geben diese Makros eine Diagnosemeldung aus.If the condition fails, these macros print a diagnostic message. Die _RPT und _RPTF Gruppe von Makros werden auch in diesem Programm ausgeführt, als Alternative zur printf -Funktion.The _RPT and _RPTF group of macros is also exercised in this program, as an alternative to the printf function.

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

Weitere InformationenSee also

DebugroutinenDebug Routines
assert Macro, _assert, _wassertassert Macro, _assert, _wassert
_RPT, _RPTF, _RPTW, _RPTFW Macros_RPT, _RPTF, _RPTW, _RPTFW Macros