<QtAssert>

Macros para comprobar condiciones durante el desarrollo y la depuración. Más...

Header: #include <QtAssert>

Funciones

T *q_check_ptr(T *p)

Macros

void Q_ASSERT(bool test)
void Q_ASSERT_X(bool test, const char *where, const char *what)
void Q_CHECK_PTR(void *pointer)
(since 6.11) void Q_PRESUME(bool expr)
void Q_UNREACHABLE()
(since 6.5) void Q_UNREACHABLE_RETURN(...)

Descripción detallada

Documentación de funciones

template <typename T> T *q_check_ptr(T *p)

Utiliza Q_CHECK_PTR en p y, a continuación, devuelve p.

Se puede utilizar como una versión en línea de Q_CHECK_PTR.

Documentación de macros

void Q_ASSERT(bool test)

Muestra 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() resulta útil para comprobar las precondiciones y poscondiciones durante el desarrollo. No realiza ninguna acción si se ha definido « QT_NO_DEBUG » 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 instrucción `Q_ASSERT` mostrará el siguiente mensaje utilizando la función ` qFatal()`:

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

Véase también Q_ASSERT_X(), qFatal() y Técnicas de depuración.

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

Muestra 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 resulta útil para comprobar las precondiciones y poscondiciones durante el desarrollo. No realiza ninguna acción si se ha definido « QT_NO_DEBUG » 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 instrucción Q_ASSERT_X mostrará el siguiente mensaje utilizando la función qFatal():

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

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

void Q_CHECK_PTR(void *pointer)

Si pointer es nullptr, muestra un mensaje que contiene el nombre del archivo del código fuente y el número de línea, indicando que el programa se ha quedado sin memoria y se interrumpe la ejecución del programa. En cambio, lanza una excepción de tipo std::bad_alloc si las excepciones están habilitadas.

Q_CHECK_PTR no hace nada si se han definido QT_NO_DEBUG y QT_NO_EXCEPTIONS durante la compilación. Por lo tanto, no debes utilizar Q_CHECK_PTR para comprobar si las asignaciones de memoria se han realizado correctamente, ya que la comprobación quedará desactivada 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);

Véase 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 genera Q_ASSERT() y un atributo [[assume]] al estilo de C++23 cuando el compilador lo admite. De lo contrario, recurre a Q_ASSERT().

Esta macro se introdujo en Qt 6.11.

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

void Q_UNREACHABLE()

Indica al compilador que no se puede llegar al punto actual mediante ninguna ejecución, por lo que puede optimizar como código muerto cualquier ruta de código que conduzca hasta aquí, así como el código que continúe a partir de aquí.

Esta macro resulta útil para marcar condiciones imposibles. Por ejemplo, dada la siguiente enumeración:

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

Se puede escribir una tabla «switch» de la siguiente manera:

    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 indica al compilador que no genere código para una variable «shape» 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 generar una advertencia indicando que no se han comprobado algunos valores de la enumeración.

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

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

Nota: Utiliza la macro Q_UNREACHABLE_RETURN() para insertar sentencias «return» en los compiladores que las necesiten, sin provocar advertencias en los compiladores que se quejen de su presencia.

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

[since 6.5] void Q_UNREACHABLE_RETURN(...)

Esto equivale a

Q_UNREACHABLE();
return __VA_ARGS__;

excepto que omite el «return» en los compiladores que darían un aviso al respecto.

Esta macro se introdujo en Qt 6.5.

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

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.