_ASSERT, _ASSERTE macros

Artigo
02/25/2013

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

_ASSERT( 
   booleanExpression 
);
_ASSERTE( 
   booleanExpression 
);

Parâmetros

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

Comentários

O _ASSERT e _ASSERTE as macros oferecem um aplicativo com um mecanismo simple e transparente para a verificação de suposições durante o processo de depuração.Eles são muito flexíveis porque eles não precisam ser colocado entre #ifdef instruções para a impedi-los de que está sendo chamado em uma compilação de um aplicativo de varejo.Essa flexibilidade é atingida usando a _ Debug macro._ASSERTe _ASSERTE estão disponíveis somente quando _DEBUG está definido.Quando _DEBUG não é definido, chamadas para essas macros são removidas durante o pré-processamento.

_ASSERTe _ASSERTE avaliar seus booleanExpression argumento e quando o resultado é false (0), imprimem uma mensagem de diagnóstico e a chamada _ CrtDbgReportW para gerar um relatório de depuração.O _ASSERT macro imprime uma mensagem de diagnóstico simples, enquanto _ASSERTE inclui uma representação de seqüência da expressão com falha na mensagem.Essas macros não fazem nada quando booleanExpression for avaliada como diferente de zero.

_ASSERTe _ASSERTE invocar _CrtDbgReportW, que faz com que toda a saída seja em caracteres de largura, e _ASSERTE imprime corretamente os caracteres Unicode em 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 fazer referência ao código-fonte do aplicativo.Entretanto, existe uma desvantagem em que cada expressão avaliada pela _ASSERTE está incluído no arquivo de (versão de depuração) de saída do seu aplicativo como uma constante de seqüência de caracteres.Portanto, se um grande número de chamadas são feitas a _ASSERTE, essas expressões podem aumentar significativamente o tamanho do seu arquivo de saída.

A menos que você especifique o contrário com o _ CrtSetReportMode e _CrtSetReportFile funções, as mensagens aparecem em uma caixa de diálogo pop-up equivalente à configuração:

_CrtSetReportMode(CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReportou _CrtDbgReportW gera o relatório de depuração e determina o seu destino ou destinos, com base na atual modo de relatório ou modos e arquivo definido para o _CRT_ASSERT tipo de relatório.Por padrão, os erros e falhas de declaração são direcionados para uma janela de mensagem de depuração.O _ CrtSetReportMode e _CrtSetReportFile funções 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 clica o novamente botão, _CrtDbgReport ou _CrtDbgReportW retorna 1, fazendo com que o _ASSERT e _ASSERTE macros para iniciar o depurador, desde que a depuração just-in-time (JIT) está habilitada.

Para obter mais informações sobre o processo de geração de relatórios, consulte o _CrtDbgReport, _ CrtDbgReportW função.Para obter mais informações sobre como solucionar falhas de declaração e usar essas macros como um mecanismo de tratamento de erros de depuração, consulte Usando Macros para verificação e emissão de relatórios.

O _RPT, _RPTF macros de depuração também estão disponíveis para gerar um relatório de depuração, mas eles não avaliar uma expressão.O _RPT macros geram um relatório simples.O _RPTF macros incluem o número de linha e o arquivo de origem onde a macro de relatório foi chamada no relatório gerado.Além de _ASSERTE macros, o ANSI assert rotina pode ser usada para verificar a lógica do programa.Esta rotina está disponível nas versões debug e release das bibliotecas.Versões de caractere largo dessas macros estão disponíveis (_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 seqüência de caracteres e saída.

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

Sendo
Biblioteca estática com vários threads, versão de depuração.
Msvcrtd.lib
Biblioteca de importação para Msvcr90d.dll, versão de depuração.

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 de string1 == string2.Se a condição falhar, essas macros imprimir uma mensagem de diagnóstico.O _RPTn e _RPTFn grupo de macros também for exercido neste programa, como 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;
}

Equivalência do .NET Framework

System::Diagnostics::Debug:: Assert

Consulte também

Referência

Rotinas de depuração

_RPT, _RPTF, _RPTW, _RPTFW macros

Partilhar via