Técnicas de depuración

Aquí presentamos algunos consejos útiles para ayudarte con la depuración de tu software basado en Qt.

Configuración de Qt para depuración

Cuando se configura Qt para su instalación, es posible asegurarse de que se construye para incluir símbolos de depuración que pueden facilitar el seguimiento de errores en aplicaciones y bibliotecas. Sin embargo, en algunas plataformas, la construcción de Qt en modo de depuración hará que las aplicaciones sean más grandes de lo deseable.

Depuración en macOS y Xcode

Depuración con/sin frameworks

Lo básico que necesitas saber sobre librerías de depuración y frameworks se encuentra en developer.apple.com en: Apple Technical Note TN2124.

Cuando construyes Qt, los frameworks se construyen por defecto, y dentro del framework encontrarás tanto una versión de lanzamiento como una de depuración (por ejemplo, QtCore y QtCore_debug). Si pasas la bandera -no-framework cuando construyes Qt, se construyen dos dylibs para cada librería Qt (por ejemplo, libQtCore.4.dylib y libQtCore_debug.4.dylib).

Lo que ocurre cuando se enlaza depende de si se utilizan frameworks o no. No vemos una razón de peso para recomendar uno sobre el otro.

Con frameworks:

Dado que las librerías de liberación y depuración están dentro del framework, la aplicación simplemente se enlaza con el framework. Entonces, cuando se ejecuta en el depurador, obtendrá la versión de lanzamiento o la versión de depuración, dependiendo de si se establece DYLD_IMAGE_SUFFIX. Si no lo estableces, obtendrás la versión de lanzamiento por defecto (es decir, no _debug). Si establece DYLD_IMAGE_SUFFIX=_debug, obtendrá la versión de depuración.

Sin Frameworks:

Cuando le dices a qmake que genere un Makefile con la configuración de depuración, enlazará con la versión _debug de las librerías y generará símbolos de depuración para la aplicación. Ejecutar este programa en GDB funcionará entonces como ejecutar GDB en otras plataformas, y podrás rastrear dentro de Qt.

Opciones de Línea de Comandos Reconocidas por Qt

Cuando ejecutas una aplicación Qt, puedes especificar varias opciones de línea de comandos que pueden ayudar con la depuración. Estas son reconocidas por QApplication.

Variables de entorno reconocidas por Qt

En tiempo de ejecución, una aplicación Qt reconoce muchas variables de entorno, algunas de las cuales pueden ser útiles para la depuración:

Mensajes de advertencia y depuración

Qt incluye macros C++ globales para escribir texto de advertencia y depuración. Las macros simples utilizan un valor predeterminado logging category; las macros de registro categorizadas permiten especificar la categoría. Puedes usarlas para los siguientes propósitos:

Si incluye el archivo de cabecera <QtDebug>, la macro qDebug() también puede utilizarse como flujo de salida. Por ejemplo:

qDebug() << "Widget" << widget << "at position" << widget->pos();

La implementación Qt de estas macros imprime en la salida stderr bajo Unix/Linux y macOS. En Windows, si se trata de una aplicación de consola, el texto se envía a consola; en caso contrario, se envía al depurador.

Por defecto, sólo se imprime el mensaje. Puede incluir información adicional configurando la variable de entorno QT_MESSAGE_PATTERN. Por ejemplo:

QT_MESSAGE_PATTERN="[%{time process} %{type}] %{appname} %{category} %{function} - %{message}"

El formato está documentado en qSetMessagePattern(). También puede instalar su propio manejador de mensajes utilizando qInstallMessageHandler().

Si se establece la variable de entorno QT_FATAL_WARNINGS, qWarning() sale después de imprimir el mensaje de advertencia. Esto facilita la obtención de un backtrace en el depurador.

qDebug(), qInfo(), y qWarning() son herramientas de depuración. Pueden eliminarse definiendo QT_NO_DEBUG_OUTPUT, QT_NO_INFO_OUTPUT, o QT_NO_WARNING_OUTPUT durante la compilación.

Las funciones de depuración QObject::dumpObjectTree() y QObject::dumpObjectInfo() suelen ser útiles cuando una aplicación tiene un aspecto o un comportamiento extraño. Son más útiles si se utiliza object names que no, pero a menudo son útiles incluso sin nombres.

En QML, dumpItemTree() sirve para el mismo propósito.

Compatibilidad con el operador de flujo qDebug()

Puedes implementar el operador de flujo utilizado por qDebug() para proporcionar soporte de depuración a tus clases. La clase que implementa el flujo es QDebug. Utilice QDebugStateSaver para guardar temporalmente las opciones de formato del stream. Utilice nospace() y QTextStream manipulators para personalizar aún más el formato.

Aquí hay un ejemplo para una clase que representa una coordenada 2D.

QDebug operator<<(QDebug dbg, const Coordinate &c)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "(" << c.x() << ", " << c.y() << ")";

    return dbg;
}

La integración de tipos personalizados con el sistema de meta-objetos de Qt se trata con más profundidad en el documento Creación de tipos Qt personalizados.

Macros de depuración

El fichero de cabecera <QtGlobal> contiene algunas macros de depuración y #defines.

Tres macros importantes son:

• Q_ASSERT(cond), donde cond es una expresión booleana, escribe la advertencia "ASSERT:'cond' in file xyz.cpp, line 234" y sale si cond es falso.
• Q_ASSERT_X(cond, where, what), donde cond es una expresión booleana, where una ubicación, y what un mensaje, escribe la advertencia "Fallo ASSERT en where: 'what', fichero xyz.cpp, línea 234" y sale si cond es falso.
• Q_CHECK_PTR(ptr), donde ptr es un puntero. Escribe la advertencia "In file xyz.cpp, line 234: Out of memory" y sale si ptr es 0.

Estas macros son útiles para detectar errores del programa, por ejemplo

char *alloc(int size)
{
    Q_ASSERT(size > 0);
    char *ptr = new char[size];
    Q_CHECK_PTR(ptr);
    return ptr;
}

Q_ASSERT(), Q_ASSERT_X(), y Q_CHECK_PTR() se expanden a nada si QT_NO_DEBUG está definido durante la compilación. Por esta razón, los argumentos de estas macros no deberían tener efectos secundarios. A continuación se muestra un uso incorrecto de Q_CHECK_PTR():

char *alloc(int size)
{
    char *ptr;
    Q_CHECK_PTR(ptr = new char[size]);  // WRONG
    return ptr;
}

Si este código se compila con QT_NO_DEBUG definido, el código de la expresión Q_CHECK_PTR() no se ejecuta y alloc devuelve un puntero no inicializado.

La biblioteca Qt contiene cientos de comprobaciones internas que imprimirán mensajes de advertencia cuando se detecte un error de programación. Por lo tanto, le recomendamos que utilice una versión de depuración de Qt cuando desarrolle software basado en Qt.

El registro y categorized logging también son posibles en QML.

Errores comunes

Hay un error que es tan común que merece ser mencionado aquí: Si incluye la macro Q_OBJECT en una declaración de clase y ejecuta el compilador de meta-objetos (moc), pero olvida enlazar el código objeto generado por moc en su ejecutable, obtendrá mensajes de error muy confusos. Cualquier error de enlace que se queje de la falta de vtbl, _vtbl, __vtbl o similar es probablemente el resultado de este problema.