Exportar (0) Imprimir
Expandir todo
and
div
eof
not
or
xor
Expandir Minimizar
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

_ASSERT, _ASSERTE (Macros)

Evaluar una expresión y generar un informe de depuración cuando el resultado es False (versión de depuración solo).

_ASSERT( 
   booleanExpression 
);
_ASSERTE( 
   booleanExpression 
);

booleanExpression

Expresión (punteros incluida que se evalúa como cero o 0.

Las macros de _ASSERT y de _ASSERTE proporcionan una aplicación con un mecanismo limpio y sencilla para comprobar suposiciones durante el proceso de depuración. Son muy flexibles porque no es necesario encerrar en las instrucciones de #ifdef para evitar que se muestran en una compilación comercial de una aplicación. Esta flexibilidad se logra mediante la macro de _DEBUG . _ASSERT y _ASSERTE sólo están disponibles cuando se define _DEBUG . Cuando _DEBUG no está definido, las llamadas a estas macros se quitan durante el preprocesamiento.

_ASSERT y _ASSERTE evalúan su argumento de booleanExpression y cuando el resultado es false (0), imprime un mensaje de diagnóstico y una llamada _CrtDbgReportW para generar un informe de depuración. La macro de _ASSERT imprime un mensaje de diagnóstico simple, mientras que _ASSERTE incluye una representación de cadena de la expresión incorrectos en el mensaje. Estas macros no hacen nada cuando booleanExpression se evalúa como cero.

_ASSERT y _ASSERTE invocan _CrtDbgReportW, que realiza el resultado esté en caracteres anchos, y _ASSERTE imprime correctamente los caracteres Unicode en booleanExpression.

Porque la macro de _ASSERTE especifica la expresión incorrectos en el informe generado, permite a los usuarios para identificar el problema sin consultar el código fuente de la aplicación. Sin embargo, una desventaja existe en que cada expresión evaluada por _ASSERTE está incluido en el archivo de salida (versión de depuración) de la aplicación como una constante de cadena. Por consiguiente, si un gran número de llamadas se hace a _ASSERTE, estas expresiones pueden aumentar considerablemente el tamaño del archivo de salida.

A menos que se especifique lo contrario con _CrtSetReportMode y funciona _CrtSetReportFile , los mensajes aparecen en un equivalente móvil del cuadro de diálogo para establecer:

_CrtSetReportMode(CRT_ASSERT, _CRTDBG_MODE_WNDW);

_CrtDbgReport o _CrtDbgReportW genera el informe de depuración y determina el destino o destinos, según el modo de informe o los modos y el archivo actuales definidos para el tipo de informe de _CRT_ASSERT . De forma predeterminada, dirigen a errores de aserción y los errores en una ventana de mensajes de depuración. Las funciones de _CrtSetReportMode y de _CrtSetReportFile se utilizan para definir los destinos para cada tipo de informe.

Cuando el destino es una ventana de mensajes de depuración y el usuario hace clic en el botón de Reintentar , _CrtDbgReport o _CrtDbgReportW devuelve 1, haciendo que macros de _ASSERT y de _ASSERTE enciendan el depurador siempre que está habilitada la depuración just-in-time de (JIT).

Para obtener más información sobre el proceso de informes, vea la función de _CrtDbgReport, _CrtDbgReportW . Para obtener más información sobre cómo resolver los errores de aserción y utilizar estas macros como mecanismo de control de errores de la depuración, vea Utilizando las macros para comprobación e informes.

Las macros de depuración de _RPT, _RPTF también están disponibles para generar un informe de depuración, pero no se evalúa una expresión. Las macros de _RPT generan un informe simple. Las macros de _RPTF incluyen el archivo de código fuente y el número de línea donde la macro de informe se denominada en el informe generado. Además de las macros de _ASSERTE , la rutina de ANSI validar se puede utilizar para comprobar la lógica. Esta rutina está disponible en las versiones de depuración y lanzamiento de bibliotecas. Las versiones de caracteres anchos de estas macros están disponibles (_RPTWn, _RPTFWn). Las versiones del carácter ancho son idénticas a las versiones estrechas de carácter salvo que las cadenas de caracteres anchos se utilizan para todos los parámetros de cadena y se generan.

Aunque _ASSERT y _ASSERTE son macros y recopilados incluye Crtdbg.h, la aplicación debe vincularse a una de las bibliotecas siguientes porque estas macros llaman a otras funciones en tiempo de ejecución.

Libcmtd.lib

Biblioteca estática multiproceso, versión de depuración.

Msvcrtd.lib

Biblioteca para Msvcr90d.dll, versión de importación de depuración.

Macro

Encabezado necesario

_ASSERT

<crtdbg.h>

_ASSERTE

<crtdbg.h>

En este programa, las llamadas se haga a macros de _ASSERT y de _ASSERTE para probar la condición string1 == string2. Si la condición, estas macros imprime un mensaje de diagnóstico. Utilizan el grupo de _RPTn y de _RPTFn de macros también en este programa, como alternativa a la función 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;
}
Use las macros assert para evaluar == p2 de expresiones p1.
crt_ASSERT_macro.c (54): 
 ¿El _ASSERT encontrará “i es” == p1 “que soy p2”?
crt_ASSERT_macro.c (55): En la aserción!
crt_ASSERT_macro.c (58): 

 ¿_ASSERTE Encontrará “i es” == p1 “que soy p2”?
crt_ASSERT_macro.c (59): La aserción: p1 == p2
¡“Soy p1”! = “Soy p2”

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft