_ASSERT, _ASSERTE macros

Artigo
08/25/2010

Avaliar uma expressão e gerar um relatório de depurar quando o resultado é False (somente a versão de depurar).

_ASSERT( 
      booleanExpression 
);
_ASSERTE( 
      booleanExpression 
);

Parâmetros

booleanExpression
Expressão (inclusive os ponteiros) que é avaliada como diferente de zero ou 0.

Comentários

The _ASSERT e _ASSERTE macros fornecem um aplicativo com um mecanismo simples e limpo para verificar as suposições durante o processo de depuração. Eles são muito flexíveis porque eles não precisam ser colocados entre #ifdef instruções para impedir que está sendo chamado em uma compilação para venda de um aplicativo. Essa flexibilidade é atingida usando a _DEBUG macro._ASSERT e _ASSERTE estão disponível somente quando _DEBUG está definido. Quando _DEBUG não é definido, chamadas para essas macros são removidas durante o pré-processamento.

_ASSERT e _ASSERTE avaliar seus booleanExpression argumento e quando o resultado é false (0), imprimem uma mensagem de diagnóstico e a telefonar _CrtDbgReportW para gerar um relatório de depurar.The _ASSERT macro imprime uma mensagem de diagnóstico simples, enquanto _ASSERTE inclui uma representação de seqüência da expressão falhou na mensagem. Essas macros não fazem nada quando booleanExpression avalia diferente de zero.

In Visual C++ 2005, _ASSERT e _ASSERTE chamar _CrtDbgReportW, que faz com que toda a saída em caracteres largos, e _ASSERTE imprime corretamente caracteres Unicode booleanExpression.

Porque o _ASSERTE macro Especifica a expressão com falha no relatório gerado, ele permite que os usuários a identificar o problema sem referência ao código-fonte do aplicativo. No entanto, existe uma desvantagem em que cada expressão avaliada por _ASSERTE está incluído no arquivo de (versão de depurar) de saída do seu aplicativo sistema autônomo uma constante de seqüência de caracteres. Portanto, se um grande número de chamadas são feitas para _ASSERTE, essas expressões podem significativamente aumentar o dimensionar do seu arquivo de saída.

A menos que você especifique de outra forma com o _CrtSetReportMode and _CrtSetReportFile funções, mensagens aparecem em uma caixa de diálogo pop-up equivalente ao:

_CrtSetReportMode(CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReport ou _CrtDbgReportW gera o relatório de depurar e determina seu destino ou destinos, com base no modo corrente do relatório ou modos e arquivo definido para o _CRT_ASSERT tipo de relatório. Por padrão, a declaração falhas e erros são direcionados para uma janela de mensagem de depurar.The _CrtSetReportMode and _CrtSetReportFile funções são usadas para definir os destinos para cada tipo de relatório.

Quando o destino for uma janela de mensagem de depurar e o usuário clica o Tente novamente botão, _CrtDbgReport ou _CrtDbgReportW Retorna 1, fazendo com que o _ASSERT e _ASSERTE as macros para iniciar o depurador fornecida se a depurar just-in-time (JIT) está ativado.

Para obter mais informações sobre o processo de emissão de relatórios, consulte o _CrtDbgReport, _CrtDbgReportW função.Para obter mais informações sobre sistema autônomo solucionar falhas de declaração e usar essas macros sistema autônomo um mecanismo de tratamento de erro de depuração, consulte Usando macros para verificação e emissão de relatórios.

The _RPT, _RPTF depurar macros também estão disponível para gerar um relatório de depurar, mas eles não avaliar uma expressão.The _RPT macros gerar um relatório simples. The _RPTF macros incluem o número de arquivo e linha de fonte onde a macro de relatório foi chamada no relatório gerado. Juntamente com o _ASSERTE macros, o ANSI declarar rotina pode ser usada para verificar a lógica do programa.Esta rotina está disponível em ambas as versões de depurar e versão das bibliotecas.In Visual C++ 2005, versões caractere largo essas macros estão disponível ()_RPTWn, _RPTFWn). As versões de caractere largo são idênticas às versões caractere estreito exceto que as seqüências de caracteres de largura são usadas para todos os parâmetros de cadeia de caracteres e saída.

Embora _ASSERT e _ASSERTE macros são e são obtidas, incluindo Crtdbg.h, o aplicativo deve vincular com um dos seguintes bibliotecas porque essas macros chamam outras funções de time de execução.

Libcmtd.lib
Biblioteca estática com vários threads, versão de depurar.
Msvcrtd.lib
Importar biblioteca para Msvcr90d.dll, versão de depurar.

Requisitos

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

Exemplo

Neste programa, as chamadas são feitas para o _ASSERT e _ASSERTE macros para testar a condição string1 == string2. Se a condição falhar, essas macros imprimir uma mensagem de diagnóstico.The _RPTn e _RPTFn agrupar de macros também exercido neste programa, sistema autônomo uma alternativa para o 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'

Equivalente do NET Framework

sistema::Diagnóstico::depurar:: Assert

Consulte também

Referência

Rotinas de depurar

_RPT _RPTF, _RPTW, _RPTFW macros

Partilhar via