<QtAssert>

Documentación de macros

void Q_ASSERT(bool test)

Imprime un mensaje de advertencia que contiene el nombre del archivo de código fuente y el número de línea si test es false.

Q_ASSERT() es útil para probar pre y post condiciones durante el desarrollo. No hace nada si QT_NO_DEBUG fue definido durante la compilación.

Ejemplo:

// File: div.cpp

#include <QtGlobal>

int divide(int a, int b)
{
    Q_ASSERT(b != 0);
        return a / b;
}

Si b es cero, la sentencia Q_ASSERT mostrará el siguiente mensaje utilizando la función qFatal():

ASSERT: "b != 0" in file div.cpp, line 7

Ver también Q_ASSERT_X(), qFatal(), y Técnicas de Depuración.

void Q_ASSERT_X(bool test, const char *where, const char *what)

Imprime el mensaje what junto con la ubicación where, el nombre del archivo fuente y el número de línea si test es false.

Q_ASSERT_X es útil para probar pre y post condiciones durante el desarrollo. No hace nada si QT_NO_DEBUG se definió durante la compilación.

Ejemplo:

// File: div.cpp

#include <QtGlobal>

int divide(int a, int b)
{
    Q_ASSERT_X(b != 0, "divide", "division by zero");
        return a / b;
}

Si b es cero, la sentencia Q_ASSERT_X mostrará el siguiente mensaje utilizando la función qFatal():

ASSERT failure in divide: "division by zero", file div.cpp, line 7

Ver también Q_ASSERT(), qFatal(), y Técnicas de depuración.

void Q_CHECK_PTR(void *pointer)

Si pointer es nullptr, imprime un mensaje que contiene el nombre del archivo del código fuente y el número de línea, diciendo que el programa se quedó sin memoria y aborta la ejecución del programa. Lanza std::bad_alloc en su lugar si las excepciones están habilitadas.

Q_CHECK_PTR no hace nada si QT_NO_DEBUG y QT_NO_EXCEPTIONS fueron definidos durante la compilación. Por lo tanto, no debe utilizar Q_CHECK_PTR para comprobar si las asignaciones de memoria se han realizado correctamente, ya que la comprobación se desactivará en algunos casos.

Ejemplo:

int *a;

Q_CHECK_PTR(a = new int[80]);   // WRONG!

a = new (std::nothrow) int[80];      // Right
Q_CHECK_PTR(a);

Ver también qWarning() y Técnicas de depuración.

[since 6.11] void Q_PRESUME(bool expr)

Hace que el compilador asuma que expr es true.

Esta macro emite Q_ASSERT() y un atributo [[assume]] estilo C++23 cuando el compilador lo admite. En caso contrario, vuelve a Q_ASSERT().

Esta macro se introdujo en Qt 6.11.

Véase también Q_ASSERT(), Q_UNREACHABLE(), Q_LIKELY(), y Q_ASSUME().

void Q_UNREACHABLE()

Indica al compilador que el punto actual no puede ser alcanzado por ninguna ejecución, por lo que puede optimizar cualquier ruta de código que conduzca aquí como código muerto, así como el código que continúe desde aquí.

Esta macro es útil para marcar condiciones imposibles. Por ejemplo, dado el siguiente enum:

   enum Shapes {
       Rectangle,
       Triangle,
       Circle,
       NumShapes
   };

Se puede escribir una tabla de conmutación como esta:

    switch (shape) {
        case Rectangle:
            return rectangle();
        case Triangle:
            return triangle();
        case Circle:
            return circle();
        case NumShapes:
            Q_UNREACHABLE();
            break;
    }

La ventaja de insertar Q_UNREACHABLE() en ese punto es que se le dice al compilador que no genere código para una variable de forma que contenga ese valor. Si falta la macro, el compilador seguirá generando las comparaciones necesarias para ese valor. Si se eliminara la etiqueta case, algunos compiladores podrían producir una advertencia de que algunos valores enum no se comprueban.

Utilizando esta macro en condiciones imposibles, se puede mejorar la cobertura del código ya que se pueden eliminar rutas de código muertas.

En las compilaciones de depuración, la condición se impone mediante un assert para facilitar la depuración.

Véase también Q_ASSERT(), qFatal(), Q_UNREACHABLE_RETURN(), y Q_PRESUME().

[since 6.5] void Q_UNREACHABLE_RETURN(...)

Es equivalente a

Q_UNREACHABLE();
return __VA_ARGS__;

excepto que omite el retorno en compiladores que advertirían de ello.

Esta macro se introdujo en Qt 6.5.

Véase también Q_UNREACHABLE() y Q_PRESUME().