Macros _ASSERT,_ASSERTE e _ASSERT_EXPR

Avalie uma expressão e gere um relatório de depuração quando o resultado for false (somente versão de depuração).

Sintaxe

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

Parâmetros

booleanExpression
Uma expressão escalar (incluindo expressões de ponteiro) avaliada como não zero (true) ou 0 (false).

message
Uma cadeia de caracteres larga para exibir como parte do relatório.

Comentários

As macros _ASSERT_EXPR, _ASSERT e _ASSERTE fornecem um aplicativo com um mecanismo simples e limpo para verificar suposições durante o processo de depuração. Eles são flexíveis porque não precisam ser colocados entre #ifdef instruções para impedir que sejam chamados em um build de varejo de um aplicativo. Essa flexibilidade é obtida usando a macro _DEBUG. _ASSERT_EXPR, _ASSERT e _ASSERTE só estão disponíveis quando _DEBUG é definido no tempo de compilação. Quando _DEBUG não está definido, as chamadas a essas macros são removidas durante o pré-processamento.

_ASSERT_EXPR, _ASSERT e _ASSERTE avaliam o argumento booleanExpression e, quando o resultado é false (0), imprimem uma mensagem de diagnóstico e chamam _CrtDbgReportW para gerar um relatório de depuração. A macro _ASSERT imprime uma mensagem de diagnóstico simples, _ASSERTE inclui uma representação de cadeia de caracteres da expressão com falha na mensagem e _ASSERT_EXPR inclui a cadeia de caracteres message na mensagem de diagnóstico. Essas macros não fazem nada quando booleanExpression é avaliado como diferente de zero.

_ASSERT_EXPR, _ASSERT e _ASSERTE invocam _CrtDbgReportW, o que faz todas as saídas estarem em caracteres largos. _ASSERTE imprime corretamente caracteres Unicode em booleanExpression e _ASSERT_EXPR imprime caracteres Unicode em message.

Porque a macro _ASSERTE especifica a expressão com falha e _ASSERT_EXPR permite especificar uma mensagem no relatório gerado, elas permitem aos usuários identificar o problema sem consultar o código-fonte do aplicativo. No entanto, há uma desvantagem no sentido de que cada message impresso por _ASSERT_EXPR e cada expressão avaliada por _ASSERTE é incluído no arquivo (versão de depuração) de saída do seu aplicativo como uma constante de cadeia de caracteres. Portanto, se um grande número de chamadas for feito para _ASSERT_EXPR ou _ASSERTE, essas expressões poderão aumentar muito o tamanho do arquivo de saída.

A menos que você especifique de outra forma com as funções _CrtSetReportMode e _CrtSetReportFile, as mensagens aparecerão em uma caixa de diálogo pop-up equivalente à configuração:

_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportW gera o relatório de depuração e determina seus destinos com base nos modos de relatório atuais e no arquivo definido para o tipo de relatório _CRT_ASSERT. Por padrão, erros e falhas de declaração são direcionados para uma janela de mensagem de depuração. As funções _CrtSetReportMode e _CrtSetReportFile são usadas para definir os destinos de cada tipo de relatório.

Quando o destino é uma janela de mensagem de depuração e o usuário seleciona o botão Repetir, _CrtDbgReportW retorna 1, fazendo com que as macros e _ASSERT _ASSERTE iniciem o depurador se a _ASSERT_EXPRdepuração JIT (just-in-time) estiver habilitada.

Para obter mais informações sobre o processo de relatório, confira a função _CrtDbgReport, _CrtDbgReportW. Para obter mais informações sobre como resolver falhas de asserção e usar essas macros como um mecanismo de tratamento de erros de depuração, consulte Macros para relatórios.

Além das macros _ASSERT, a macro assert pode ser usada para verificar a lógica do programa. Essa macro está disponível nas versões de depuração e liberação das bibliotecas. As macros de depuração _RPT, _RPTF também estão disponíveis para gerar um relatório de depuração, mas não avaliam uma expressão. As macros _RPT geram um relatório simples. As macros _RPTF incluem o arquivo de origem e o número de linha no qual a macro do relatório foi chamada no relatório gerado. Estão disponíveis versões de caracteres largos dessas macros (_RPTW, _RPTFW). As versões de caractere largo são idênticas às versões de caractere estreito, exceto que cadeias de caracteres largos são usadas para todos os parâmetros de cadeia de caracteres e de saída.

Embora _ASSERT_EXPR, _ASSERT e _ASSERTE sejam macros e estejam disponíveis pela inclusão de <crtdbg.h>, o aplicativo deve ser vinculado a uma versão de depuração da biblioteca de runtime do C quando _DEBUG for definido, pois essas macros chamam outras funções do runtime.

Requisitos

Macro	Cabeçalho necessário
_ASSERT_EXPR, _ASSERT, _ASSERTE	<crtdbg.h>

Exemplo

Neste programa, as chamadas são feitas para as macros _ASSERT e _ASSERTE para testar a condição string1 == string2. Se a condição falhar, essas macros imprimirão uma mensagem de diagnóstico. O grupo de macros _RPT e _RPTF também é utilizado neste programa, como uma alternativa à função 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'

Confira também

Rotinas de depuração
Macro assert, _assert, _wassert
Macros _RPT, _RPTF, _RPTW, _RPTFW