Macros _ASSERT, _ASSERTE

Artigo
06/09/2015

Avalia uma expressão e gerencia um relatório de depuração quando o resultado é False (versão de depuração somente).

_ASSERT( 
   booleanExpression 
);
_ASSERTE( 
   booleanExpression 
);

Parâmetros

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

Comentários

Macros de _ASSERT e de _ASSERTE fornecem um aplicativo com um mecanismo simples e direta para verificar suposições durante o processo de depuração. São muito flexíveis porque não precisam ser incluídos em instruções de #ifdef para evitar que sejam chamadas em uma compilação de varejo de um aplicativo. Essa flexibilidade é obtida com a macro de _DEBUG . _ASSERT e _ASSERTE só estão disponíveis quando _DEBUG é definido. Quando _DEBUG não for definido, as chamadas para esses macros serão removidos durante pré-processamento.

_ASSERT e _ASSERTE valor de seu argumento booleanExpression e quando o resultado é false (0), imprime uma mensagem de diagnóstico e chama _CrtDbgReportW para gerar um relatório de depuração. A macro de _ASSERT imprime uma mensagem de diagnóstico simples, quando _ASSERTE incluir uma representação de cadeia de caracteres de expressão falha na mensagem. Esses macros não faz nada quando booleanExpression avalia como diferente de zero.

_ASSERT e _ASSERTE invoca _CrtDbgReportW, que faz com que todas as saídas estão em caracteres amplos, e _ASSERTE imprime corretamente caracteres Unicode em booleanExpression.

Como a macro de _ASSERTE especifica a expressão com falha no relatório gerado, permite que os usuários para identificar o problema sem fazer referência ao código-fonte do aplicativo. No entanto, uma desvantagem existir que cada expressão avaliada por _ASSERTE será incluída no arquivo de saída (versão de depuração) do aplicativo como uma constante de cadeia de caracteres. Em virtude disso, se um grande número de chamadas são feitas a _ASSERTE, essas expressões podem aumentar significativamente o tamanho do arquivo de saída.

A menos que você especifique de outra forma com as funções de _CrtSetReportMode e de _CrtSetReportFile , as mensagens aparecem em um equivalente pop-up da caixa de diálogo para definir:

_CrtSetReportMode(CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReport ou _CrtDbgReportW gerenciem o relatório de depuração e determina seus destino ou destinos, com base no modo de relatório ou os modos e o arquivo atual definido para o tipo de relatório de _CRT_ASSERT . Por padrão, as falhas de asserção e erros são redirecionados para uma janela de mensagem de depuração. As funções de _CrtSetReportMode e de _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 clicar no botão de Repetir , _CrtDbgReport ou _CrtDbgReportW retornam 1, fazendo com que as macros de _ASSERT e de _ASSERTE liguem o depurador contanto que (JIT) de depuração just-in-time está habilitado.

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

Macros de depuração de _RPT, _RPTF também estão disponíveis para gerar um relatório de depuração, mas não avalia uma expressão. Macros de _RPT gerencia um relatório simples. Macros de _RPTF incluem o arquivo de origem e o número da linha onde a macro de relatório foi chamado no relatório gerado. Além das macros de _ASSERTE , a rotina ANSI assert pode ser usada para verificar a lógica do programa. Esta rotina está disponível na depuração e nas versões de inicialização das bibliotecas. As versões principais de caracteres desses macros estão disponíveis (_RPTWn, _RPTFWn). As versões principais de caracteres são idênticas às versões estreitas de caractere com exceção de que as cadeias de caracteres amplas são usados para todos os parâmetros e saída de cadeia de caracteres.

Embora _ASSERT e _ASSERTE são macros e sejam obtidos incluindo Crtdbg.h, o aplicativo deve vincular a uma das bibliotecas como esses macros chamam outras funções de tempo de execução.

Libcmtd.lib
Biblioteca estático Multithread, versão de depuração.
Msvcrtd.lib
Biblioteca para Msvcr90d.dll, versão de importaçã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 macros de _ASSERT e de _ASSERTE para testar a condição string1 == string2. Se a condição falha, esses macros emitem uma mensagem de diagnóstico. O grupo de _RPTn e de _RPTFn de macros também é exercitado desse programa, como uma alternativa à função de 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;
}

Equivalência do .NET Framework

System::Diagnostics::Debug::Assert

Consulte também

Referência

Rotinas de depuração

Macros _RPT, _RPTF, _RPTW, _RPTFW

Compartilhar via