logica - assert c++ ejemplo
¿Qué son aserciones? y por qué los usarías? (8)
¿Cómo se hacen las aserciones en c ++? El código de ejemplo es apreciado.
Aquí hay una definición de lo que es una aserción y aquí hay un código de muestra. En pocas palabras, una afirmación es una forma para que un desarrollador pruebe sus suposiciones sobre el estado del código en cualquier punto dado. Por ejemplo, si estuviera haciendo el siguiente código:
mypointer->myfunct();
Probablemente desee afirmar que mypointer no es NULL porque esa es su suposición: mypointer nunca será NULL antes de la llamada.
Esto no aborda la facilidad de afirmación que nos ha llegado desde los primeros C días, pero también debe conocer la funcionalidad de Boost StaticAssert , en caso de que sus proyectos puedan usar Boost.
La afirmación C / C ++ estándar funciona durante el tiempo de ejecución. La función Boost StaticAssert le permite realizar algunas clases de aserciones en tiempo de compilación, detectando errores lógicos y similares incluso antes.
La aserción son expresiones booleanas que, por lo general, siempre deben ser verdaderas.
Se utilizan para garantizar que lo que espera es también lo que sucede.
void some_function(int age)
{
assert(age > 0);
}
Usted escribió la función para lidiar con las edades, también ''sabe'' con certeza que siempre está pasando argumentos razonables, luego usa una afirmación. Es como decir "sé que esto nunca puede salir mal, pero si lo hace, quiero saber", porque, bueno, todos cometemos errores.
Por lo tanto, no es para verificar si el usuario es sensible, si hay situaciones donde algo puede salir mal, no use una afirmación. Haz verificaciones reales y lidia con los errores.
Las afirmaciones son típicamente solo para compilaciones de depuración, así que no coloque código con efectos secundarios en las afirmaciones.
Las afirmaciones se usan para verificar supuestos de diseño, generalmente en términos de parámetros de entrada y resultados de retorno. Por ejemplo
// Given customer and product details for a sale, generate an invoice
Invoice ProcessOrder(Customer Cust,Product Prod)
{
assert(IsValid(Cust));
assert(IsValid(Prod);
''
''
''
assert(IsValid(RetInvoice))
return(RetInvoice);
}
Las declaraciones de afirmación no son necesarias para que el código se ejecute, pero verifican la validez de la entrada y la salida. Si la entrada no es válida, hay un error en la función de llamada. Si la entrada es válida y la salida no es válida, hay un error en este código. Ver diseño por contrato para más detalles de este uso de afirmaciones.
Editar: como se señala en otras publicaciones, la implementación predeterminada de assert no está incluida en el tiempo de ejecución de la versión. Una práctica común que muchos usarían, incluyéndome a mí, es reemplazarla con una versión incluida en la compilación de lanzamiento, pero solo se llama en un modo de diagnóstico. Esto permite realizar pruebas de regresión adecuadas en compilaciones de lanzamiento con verificación de aserción completa. Mi versión es la siguiente;
extern void _my_assert(void *, void *, unsigned);
#define myassert(exp) /
{ /
if (InDiagnostics) /
if ( !(exp) ) /
_my_assert(#exp, __FILE__, __LINE__); /
} /
Hay una pequeña sobrecarga de tiempo de ejecución en esta técnica, pero hace que el seguimiento de cualquier error que haya llegado al campo sea mucho más fácil.
Las afirmaciones son afirmaciones que le permiten probar cualquier suposición que pueda tener en su programa. Esto es especialmente útil para documentar la lógica de su programa (condiciones previas y posteriores). Las afirmaciones que fallan generalmente arrojan errores de tiempo de ejecución, y son señales de que algo está muy mal con tu programa: tu afirmación falló porque algo que creías que era cierto no lo era. Las razones usuales son: hay un error en la lógica de su función, o la persona que llama de su función le pasó datos erróneos.
Las afirmaciones son una forma de verificar explícitamente las suposiciones que hace su código, lo que le ayuda a rastrear muchos errores al reducir los posibles problemas. Por lo general, solo se evalúan en una versión especial de "depuración" de su aplicación, por lo que no ralentizarán la versión de lanzamiento final.
Digamos que usted escribió una función que tomó un puntero como argumento. Hay una buena posibilidad de que su código suponga que el puntero no es NULL, entonces ¿por qué no verificarlo explícitamente con una aserción? Así es cómo:
#include <assert.h>
void function(int* pointer_arg)
{
assert(pointer_arg != NULL);
...
}
Una cosa importante a tener en cuenta es que las expresiones que afirme nunca deben tener efectos secundarios, ya que no estarán presentes en la compilación de lanzamiento. Entonces nunca hagas algo como esto:
assert(a++ == 5);
A algunas personas también les gusta agregar pequeños mensajes a sus afirmaciones para ayudarles a darles un significado. Como una cadena siempre se convierte en verdadera, podrías escribir esto:
assert((a == 5) && "a has the wrong value!!");
Una afirmación es algo que agrega a su programa que hace que el programa se detenga inmediatamente si se cumple una condición y muestra un mensaje de error. Generalmente los usa para cosas que cree que nunca pueden suceder en su código.
Use aserciones para verificar situaciones "no puede suceder".
Uso típico: verifique los argumentos inválidos / imposibles en la parte superior de una función.
Rara vez se ve, pero sigue siendo útil: invariantes de bucle y postcondiciones.