_ASSERT, _ASSERTE, _ASSERT_EXPR macro

Valutare un'espressione e generare un report di debug quando il risultato è false (solo versione di debug).

Sintassi

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

Parametri

booleanExpression
Espressione scalare (incluse le espressioni puntatore) che restituisce un valore diverso da zero (true) oppure 0 (false).

message
Stringa di caratteri wide come parte del report.

Osservazioni:

Le macro _ASSERT_EXPR, _ASSERT e _ASSERTE forniscono a un'applicazione un semplice sistema per controllare i presupposti durante il processo di debug. Sono flessibili perché non devono essere racchiusi tra #ifdef istruzioni per impedire che vengano chiamati in una compilazione definitiva di un'applicazione. Questa flessibilità viene ottenuta usando la _DEBUG macro. _ASSERT_EXPR, _ASSERT e _ASSERTE sono disponibili solo quando _DEBUG è definito in fase di compilazione. Quando _DEBUG non viene definita, le chiamate a queste macro vengono rimosse durante la pre-elaborazione.

_ASSERT_EXPRe _ASSERT valutano booleanExpression l'argomento e _ASSERTE quando il risultato è false (0), stampano un messaggio di diagnostica e chiamano _CrtDbgReportW per generare un report di debug. La _ASSERT macro stampa un messaggio di diagnostica semplice, _ASSERTE include una rappresentazione di stringa dell'espressione non riuscita nel messaggio e _ASSERT_EXPR include la message stringa nel messaggio di diagnostica. Queste macro non eseguono alcuna operazione quando booleanExpression restituisce un risultato diverso da zero.

_ASSERT_EXPR, _ASSERT e _ASSERTE invocano _CrtDbgReportW, che fa sì che tutto l'output sia in caratteri wide. _ASSERTE stampa correttamente i caratteri Unicode in booleanExpression e _ASSERT_EXPR stampa i caratteri Unicode in message.

Dal momento che la macro _ASSERTE specifica l'espressione non riuscita e _ASSERT_EXPR consente di specificare un messaggio nel report generato, le macro consentono agli utenti di identificare il problema senza fare riferimento al codice sorgente dell'applicazione. Tuttavia, uno svantaggio è che ogni message stampato da _ASSERT_EXPR e tutte le espressioni valutate da _ASSERTE vengono inclusi nel file di output (versione di debug) dell'applicazione come una costante di stringa. Di conseguenza, se viene effettuato un numero elevato di chiamate a _ASSERT_EXPR o a _ASSERTE, queste espressioni possono aumentare notevolmente le dimensioni del file di output.

A meno che non si specifichi diversamente con le _CrtSetReportMode funzioni e _CrtSetReportFile , i messaggi vengono visualizzati in una finestra di dialogo popup equivalente all'impostazione:

_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportW genera il report di debug e ne determina la destinazione o destinazioni, in base alla modalità Report o le modalità e il file definito per il tipo di rapporto _CRT_ASSERT . Per impostazione predefinita, le asserzioni non riuscite e gli errori di asserzione vengono indirizzati a una finestra di messaggio di debug. Le _CrtSetReportMode funzioni e _CrtSetReportFile vengono usate per definire le destinazioni per ogni tipo di report.

Quando la destinazione è una finestra di messaggio di debug e l'utente seleziona il pulsante Riprova, _CrtDbgReportW restituisce 1, causando l'avvio delle _ASSERT_EXPR_ASSERT macro e _ASSERTE se è abilitato il debug JIT (Just-In-Time).

Per altre informazioni sul processo di creazione di report, vedere la funzione , _CrtDbgReportW ._CrtDbgReport Per altre informazioni sulla risoluzione degli errori di asserzione e sull'uso di queste macro come meccanismo di gestione degli errori di debug, vedere Macro per la creazione di report.

Oltre alle _ASSERT macro, la macro può essere usata per verificare la assert logica del programma. Questa macro è disponibile nelle versioni di debug e rilascio delle librerie. Le _RPTmacro di _RPTF debug sono disponibili anche per la generazione di un report di debug, ma non valutano un'espressione. Le macro _RPT generano un report semplice. Le macro _RPTF includono il file di origine e il numero di riga in cui è stata chiamata la macro di report nel report generato. Sono disponibili anche le versioni a caratteri wide di queste macro (_RPTW, _RPTFW). Le versioni a caratteri wide sono identiche alle versioni a caratteri narrow ad eccezione del fatto che le stringhe a caratteri wide vengono usate per tutti i parametri di stringa e l'output.

Anche se _ASSERT_EXPR, _ASSERT e _ASSERTE sono macro e sono disponibili includendo <crtdbg.h>, l'applicazione deve collegare con una versione di debug della libreria di runtime C quando _DEBUG viene definita perché queste macro chiamano altre funzioni di runtime.

Requisiti

Macro	Intestazione obbligatoria
_ASSERT_EXPR, _ASSERT, _ASSERTE	<crtdbg.h>

Esempio

In questo programma, vengono effettuate chiamate alle macro _ASSERT e _ASSERTE per testare la condizione string1 == string2. Se la condizione non riesce, queste macro stampano un messaggio di diagnostica. In questo programma viene anche usato il gruppo di macro _RPT e _RPTF in alternativa alla funzione 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'

Vedi anche

Routine di debug
assert Macro, _assert, _wassert
_RPT, _RPTF, _RPTW, macro _RPTFW