Partilhar via

_ASSERT, _ASSERTE, _ASSERT_EXPR Macros

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) que é avaliada como diferente de zero (true) ou 0 (false).

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

Observações

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

_ASSERT_EXPR _ASSERTE e avaliam seu booleanExpression argumento e, _ASSERT quando o resultado é false (0), imprimem uma mensagem de diagnóstico e chamam _CrtDbgReportW para gerar um relatório de depuração. A _ASSERT macro 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 message cadeia de caracteres na mensagem de diagnóstico. Essas macros não fazem nada quando booleanExpression avaliadas como diferentes de zero.

_ASSERT_EXPR _ASSERTE e _ASSERT invocar _CrtDbgReportW, o que faz com que toda a saída esteja em caracteres largos. _ASSERTE imprime corretamente caracteres Unicode e booleanExpression imprime _ASSERT_EXPR caracteres Unicode no message.

Como a _ASSERTE macro especifica a expressão com falha e _ASSERT_EXPR permite especificar uma mensagem no relatório gerado, eles permitem que os usuários identifiquem o problema sem fazer referência ao código-fonte do aplicativo. No entanto, existe uma desvantagem no fato de que cada message expressão impressa por _ASSERT_EXPR e avaliada por _ASSERTE é incluída no arquivo de saída (versão de depuração) do seu aplicativo como uma constante de cadeia de caracteres. Portanto, se um grande número de chamadas são feitas para _ASSERT_EXPR ou _ASSERTE, essas expressões podem aumentar muito o tamanho do seu arquivo de saída.

A menos que você especifique o contrário com as funções e _CrtSetReportFile , as _CrtSetReportMode mensagens aparecem 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 seu destino ou destinos, com base no modo ou modos de relatório atuais e no arquivo definido para o tipo de _CRT_ASSERT relatório. Por padrão, falhas de asserção e erros são direcionados para uma janela de mensagem de depuração. As _CrtSetReportMode funções e _CrtSetReportFile são usadas para definir os destinos para 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 o , _ASSERT e _ASSERTE as macros iniciem o depurador se a _ASSERT_EXPRdepuração just-in-time (JIT) estiver habilitada.

Para obter mais informações sobre o processo de relatório, consulte a _CrtDbgReportfunção , _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, a macro pode ser usada para verificar a lógica do _ASSERTassert programa. Esta macro está disponível nas versões de depuração e lançamento das bibliotecas. As _RPTmacros , _RPTF debug também estão disponíveis para gerar um relatório de depuração, mas não avaliam uma expressão. As _RPT macros geram um relatório simples. As _RPTF macros incluem o arquivo de origem e o número da linha onde a macro de relatório foi chamada no relatório gerado. Versões de caracteres largos dessas macros estão disponíveis (_RPTW, _RPTFW). As versões de caracteres largos são idênticas às versões de caracteres estreitos, exceto que cadeias de caracteres largos são usadas para todos os parâmetros de cadeia de caracteres e saída.

Embora _ASSERT_EXPR, _ASSERT e _ASSERTE são macros e estão disponíveis incluindo <crtdbg.h>, o aplicativo deve vincular com uma versão de depuração da biblioteca de tempo de execução C quando _DEBUG é definido porque essas macros chamam outras funções de tempo de execução.

Requerimentos

Macro Cabeçalho obrigatório
_ASSERT_EXPR, _ASSERT, _ASSERTE <crtdbg.h>

Example

Neste programa, são feitas chamadas para o _ASSERT e _ASSERTE macros para testar a condição string1 == string2. Se a condição falhar, essas macros imprimirão uma mensagem de diagnóstico. O _RPT e _RPTF grupo de macros também é exercido neste programa, como alternativa à printf função.

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

Consulte também

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

  • Last updated on