¿Qué es la función “afirmar”?

Estuve estudiando tutoriales de OpenCV y me encontré con la función assert ; ¿Qué hace?

assert terminará el progtwig (generalmente con un mensaje que cite la statement assert) si su argumento resulta ser falso. Se usa comúnmente durante la depuración para hacer que el progtwig falle más obviamente si ocurre una condición inesperada.

Por ejemplo:

 assert(length >= 0); // die if length is negative. 

También puede agregar un mensaje más informativo para que se muestre si falla así:

 assert(length >= 0 && "Whoops, length can't possibly be negative! (didn't we just check 10 lines ago?) Tell jsmith"); 

O algo como esto:

 assert(("Length can't possibly be negative! Tell jsmith", length >= 0)); 

Cuando está realizando una comstackción de lanzamiento (sin depuración), también puede eliminar la sobrecarga de evaluar las afirmaciones de afirmación definiendo la macro NDEBUG , generalmente con un NDEBUG comstackdor. El corolario de esto es que su progtwig nunca debe confiar en la ejecución de macros assert.

 // BAD assert(x++); // GOOD assert(x); x++; // Watch out! Depends on the function: assert(foo()); // Here's a safer way: int ret = foo(); assert(ret); 

A partir de la combinación del progtwig que llama abort () y no se garantiza que haga nada, afirma que solo se debe usar para probar cosas que el desarrollador ha asumido en lugar de, por ejemplo, que el usuario ingrese un número en lugar de una letra (que debería ser manejado por otros medios).

La aseveración de la statement de la computadora es análoga a la statement, asegúrese en inglés.

Echa un vistazo a

progtwig de ejemplo assert () en C ++

Muchos comstackdores ofrecen una macro assert (). La macro assert () devuelve TRUE si su parámetro evalúa TRUE y toma algún tipo de acción si evalúa FALSE. Muchos comstackdores abortarán el progtwig en un assert () que falle; otros lanzarán una excepción

Una poderosa característica de la macro assert () es que el preprocesador lo colapsa en ningún código si DEBUG no está definido. Es una gran ayuda durante el desarrollo, y cuando el producto final se envía, no hay penalización de rendimiento ni aumento en el tamaño de la versión ejecutable del progtwig.

P.ej

 #include  #include  void analyze (char *, int); int main(void) { char *string = "ABC"; int length = 3; analyze(string, length); printf("The string %s is not null or empty, " "and has length %d \n", string, length); } void analyze(char *string, int length) { assert(string != NULL); /* cannot be NULL */ assert(*string != '\0'); /* cannot be empty */ assert(length > 0); /* must be positive */ } /**************** Output should be similar to ****************** The string ABC is not null or empty, and has length 3 

El assert () puede diagnosticar errores del progtwig. Se define en ASSERT.H, y su prototipo es

void assert (int expresión); La expresión de argumento puede ser cualquier cosa que desee probar: una variable o cualquier expresión de C. Si la expresión se evalúa como VERDADERO, assert () no hace nada. Si la expresión se evalúa como FALSE, assert () muestra un mensaje de error en stderr y anula la ejecución del progtwig.

¿Cómo se usa assert ()? Se utiliza con mayor frecuencia para rastrear errores del progtwig (que son distintos de los errores de comstackción). Un error no impide que un progtwig se compile, pero causa resultados incorrectos o se ejecuta incorrectamente (por ejemplo, locking). Por ejemplo, un progtwig de análisis financiero que está escribiendo podría ocasionalmente dar respuestas incorrectas. Sospecha que el problema está causado por la variable interest_rate que toma un valor negativo, que nunca debería ocurrir. Para verificar esto, coloque la statement

assert (interest_rate> = 0); en ubicaciones en el progtwig donde se usa interest_rate. Si la variable alguna vez se vuelve negativa, la macro assert () lo alerta. Luego puede examinar el código relevante para ubicar la causa del problema.

Para ver cómo funciona assert (), ejecute el progtwig de ejemplo a continuación . Si ingresa un valor distinto de cero, el progtwig muestra el valor y finaliza normalmente. Si ingresa cero, la macro assert () fuerza la terminación anormal del progtwig. El mensaje de error exacto que verá dependerá de su comstackdor, pero aquí hay un ejemplo típico:

La aserción falló: x, lista de archivos19_3.c, línea 13 Tenga en cuenta que, para que assert () funcione, su progtwig debe comstackrse en modo de depuración. Consulte la documentación del comstackdor para obtener información sobre cómo habilitar el modo de depuración (como se explicó en un momento). Cuando luego comstack la versión final en modo de lanzamiento, las macros assert () están deshabilitadas.

  int x; printf("\nEnter an integer value: "); scanf("%d", &x); assert(x >= 0); printf("You entered %d.\n", x); return(0); 

Ingrese un valor entero: 10

Usted ingresó 10.

Ingrese un valor entero: -1

Mensaje de error: terminación anormal del progtwig

Su mensaje de error puede diferir, dependiendo de su sistema y comstackdor, pero la idea general es la misma.

Cosas como ‘plantea excepción’ y ‘detiene la ejecución’ podría ser cierto para la mayoría de los comstackdores, pero no para todos. (Por cierto, ¿hay declaraciones afirmativas que realmente arrojan excepciones?)

Aquí hay un significado interesante, ligeramente diferente de assert usado por c6x y otros comstackdores de TI: al ver ciertas afirmaciones de afirmación, estos comstackdores usan la información en esa statement para realizar ciertas optimizaciones. Malvado.

Ejemplo en C:

 int dot_product(short *x, short *y, short z) { int sum = 0 int i; assert( ( (int)(x) & 0x3 ) == 0 ); assert( ( (int)(y) & 0x3 ) == 0 ); for( i = 0 ; i < z ; ++i ) sum += x[ i ] * y[ i ]; return sum; } 

Esto le dice al comstackdor que las matrices están alineadas en los límites de 32 bits, por lo que el comstackdor puede generar instrucciones específicas para ese tipo de alineación.

Assert le permite detener la ejecución si una condición (aserción) es falsa.

Por ejemplo (Pseudocódigo):

 Bank myBank = Bank.GetMyStuff(); assert(myBank != NULL); // .. Continue. 

Si myBank es NULL, la función detendrá la ejecución y se producirá un error. Esto es muy bueno para hacer que cierto código reutilizable acepte las condiciones correctas, etc.

Es una función que detendrá la ejecución del progtwig si el valor que ha evaluado es falso. Por lo general, está rodeado por una macro para que no se compile en el binario resultante cuando se comstack con la configuración de lanzamiento.

Está diseñado para ser utilizado para probar las suposiciones que ha realizado. Por ejemplo:

 void strcpy(char* dest, char* src){ //pointers shouldn't be null assert(dest!=null); assert(src!=null); //copy string while(*dest++ = *src++); } 

El ideal que desea es que pueda cometer un error en su progtwig, como llamar a una función con argumentos inválidos, y hacer clic en una afirmación antes de segfeperar (o no funciona como se espera)

Calado estándar C ++ 11 N3337

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf

19.3 Afirmaciones

1 El encabezado , descrito en (Tabla 42), proporciona una macro para documentar las aserciones del progtwig C ++ y un mecanismo para deshabilitar las comprobaciones de aserción.

2 El contenido es el mismo que el encabezado de la biblioteca estándar C .

Calado estándar C99 N1256

http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

7.2 Diagnóstico

1 El encabezado define la macro assert y se refiere a otra macro, NDEBUG que no está definida por . Si NDEBUG se define como un nombre de macro en el punto en el archivo de origen donde se incluye , la macro assert se define simplemente como

  #define assert(ignore) ((void)0) 

La macro assert se redefine de acuerdo con el estado actual de NDEBUG cada vez que se incluye .

2. La macro assert se implementará como una macro, no como una función real. Si se suprime la definición de macro para acceder a una función real, el comportamiento no está definido.

7.2.1 Diagnósticos del progtwig

7.2.1.1 La macro assert

Sinopsis

1.

 #include  void assert(scalar expression); 

Descripción

2 La macro assert define las pruebas de diagnóstico en los progtwigs; se expande a una expresión vacía Cuando se ejecuta, si la expresión (que tendrá un tipo escalar) es falsa (es decir, se compara con 0), la macro assert escribe información sobre la llamada particular que falló (incluido el texto del argumento, el nombre del el archivo de origen, el número de línea fuente y el nombre de la función __FILE__ ; estos últimos son respectivamente los valores de las macros de preprocesamiento __FILE__ y __LINE__ y del identificador __func__ ) en la secuencia de error estándar en un formato definido por la implementación. 165) Luego llama a la función abortar.

Devoluciones

3 La macro assert no devuelve ningún valor.

Además, puede usarlo para verificar si la asignación dinámica fue exitosa.

Ejemplo de código:

 int ** p; p = new int * [5]; // Dynamic array (size 5) of pointers to int for (int i = 0; i < 5; ++i) { p[i] = new int[3]; // Each i(ptr) is now pointing to a dynamic // array (size 3) of actual int values } assert (p); // Check the dynamic allocation. 

Similar a:

 if (p == NULL) { cout << "dynamic allocation failed" << endl; exit(1); }