c++ - revista - funcion de la oficina de etica gubernamental

¿Qué es la función de "afirmar"? (9)

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 ciertos códigos reutilizables acepten las condiciones correctas, etc.

He estado estudiando los tutoriales de OpenCV y encontré la función de assert ; ¿Qué hace?

Cosas como ''provoca excepciones'' y ''detiene la ejecución'' pueden ser ciertas para la mayoría de los compiladores, pero no para todos. (Por cierto, ¿hay afirmaciones que realmente hacen excepciones?)

Aquí hay un significado interesante y ligeramente diferente de asertivo usado por c6x y otros compiladores de TI: al ver ciertas declaraciones de aserción, estos compiladores usan la información en esa declaración 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 indica al compilador que las matrices están alineadas en los límites de 32 bits, por lo que el compilador puede generar instrucciones específicas para ese tipo de alineación.

Echa un vistazo a

Programa de ejemplo assert () en C ++

Muchos compiladores ofrecen una macro assert (). La macro assert () devuelve VERDADERO si su parámetro evalúa VERDADERO y realiza algún tipo de acción si evalúa FALSO. Muchos compiladores abortarán el programa en un assert () que falla; otros lanzarán una excepción
Una característica poderosa 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 programa.

P.ej

#include <stdio.h> #include <assert.h> 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

Es una función que detendrá la ejecución del programa 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 compila con la configuración de lanzamiento.

Está diseñado para ser utilizado para probar los supuestos 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++); }

Lo ideal que desea es que pueda cometer un error en su programa, como llamar a una función con argumentos no válidos, y hacer clic en una afirmación antes de que se active (o no funcione como se esperaba)

La declaración de la computadora de Assert es análoga a la declaración de asegurarse en inglés.

La función assert () puede diagnosticar errores de programa. Se define en <assert.h> , y su prototipo es

void assert(int expression);

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

¿Cómo usas assert ()? Se utiliza con más frecuencia para localizar errores en los programas (que son distintos de los errores de compilación). Un error no impide que un programa se compile, pero hace que dé resultados incorrectos o que se ejecute incorrectamente (bloqueo, por ejemplo). Por ejemplo, un programa de análisis financiero que está escribiendo en ocasiones puede dar respuestas incorrectas. Sospecha que el problema se debe a que la variable interest_rate toma un valor negativo, lo que nunca debería ocurrir. Para comprobar esto, coloque la declaración.

afirmar (tasa de interés> = 0); en ubicaciones en el programa donde se utiliza interest_rate. Si la variable llega a ser negativa, la macro assert () te alerta. A continuación, puede examinar el código relevante para localizar la causa del problema.

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

Falló la aserción: x, lista de archivos 19_3.c, línea 13 Tenga en cuenta que, para que funcione assert (), su programa debe compilarse en el modo de depuración. Consulte la documentación de su compilador para obtener información sobre cómo habilitar el modo de depuración (como se explica en un momento). Cuando luego compila la versión final en modo de lanzamiento, las macros de assert () se deshabilitan.

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

Introduzca un valor entero: 10

Has introducido 10.

Introduzca un valor entero: -1

Mensaje de error: terminación anormal del programa

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

assert terminará el programa (generalmente con un mensaje que cita la declaración de assert) si su argumento resulta ser falso. Se usa comúnmente durante la depuración para hacer que el programa 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 bien de esta manera:

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

Cuando realiza una compilación de versión (sin depuración), también puede eliminar la sobrecarga de evaluar las declaraciones de afirmación definiendo la macro NDEBUG , generalmente con un conmutador de compilación. El corolario de esto es que su programa nunca debe confiar en la ejecución de la macro 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);

Desde la combinación del programa que llama a abortar () y no se garantiza que haga nada, las afirmaciones solo deben usarse 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 debe ser manejado por otros medios).

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); }

C ++ 11 N3337 borrador estándar

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

19.3 Afirmaciones

1 El encabezado <cassert>, descrito en (Tabla 42), proporciona una macro para documentar las aserciones del programa C ++ y un mecanismo para deshabilitar las comprobaciones de aserción.
2 El contenido es el mismo que el encabezado de la biblioteca C estándar <assert.h>.

C99 N1256 borrador estándar

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

7.2 Diagnósticos <assert.h>

1 El encabezado <assert.h> define la macro de <assert.h> y hace referencia a otra macro, NDEBUG que no está definida por <assert.h> . Si NDEBUG se define como un nombre de macro en el punto del archivo de origen donde se incluye <assert.h>, la macro de aserción 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 <assert.h> .
2. La macro de afirmación se implementará como una macro, no como una función real. Si la definición de la macro se suprime para acceder a una función real, el comportamiento no está definido.

7.2.1 Diagnóstico del programa

7.2.1.1 La macro de afirmación

Sinopsis
1.
#include <assert.h> void assert(scalar expression);
Descripción
2 La macro Assert pone pruebas de diagnóstico en programas; 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 igual a 0), la macro de afirmación escribe información sobre la llamada particular que falló (incluido el texto del argumento, el nombre del archivo de origen, el número de línea de origen 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) Entonces llama a la función abortar.
Devoluciones
3 La macro de afirmación no devuelve ningún valor.