En esta página

Seguridad ante excepciones

Advertencia preliminar: ¡La seguridad ante excepciones aún no está totalmente desarrollada! Los casos más comunes deberían funcionar, pero es posible que las clases sigan presentando fugas o incluso se cuelguen.

Qt en sí mismo no lanza excepciones. En su lugar, se utilizan códigos de error. Además, algunas clases muestran mensajes de error visibles para el usuario, por ejemplo, ` QIODevice::errorString()` o ` QSqlQuery::lastError()`. Esto se debe a razones históricas y prácticas: activar las excepciones puede aumentar el tamaño de la biblioteca en más de un 20 %.

Las secciones siguientes describen el comportamiento de Qt si se habilita el soporte para excepciones en tiempo de compilación.

Módulos a prueba de excepciones

Contenedores

Las clases contenedoras de Qt son, por lo general, neutras respecto a las excepciones. Transmiten al usuario cualquier excepción que se produzca dentro del tipo que contienen T, al tiempo que mantienen válido su estado interno.

Ejemplo:

QList<QString> list;
...
try {
    list.append("hello");
} catch (...) {
}
// list is safe to use - the exception did not affect it.

Las excepciones a esta regla son los contenedores para tipos que pueden lanzar excepciones durante la asignación o las construcciones de copia. Para esos tipos, las funciones que modifican el contenedor y, además, devuelven un valor, no son seguras de usar:

MyType s = list.takeAt(2);

Si se produce una excepción durante la asignación de ` s`, el valor del índice 2 ya se ha eliminado del contenedor, pero aún no se ha asignado a ` s `. Se pierde sin posibilidad de recuperación.

La forma correcta de escribirlo:

MyType s = list.at(2);
list.removeAt(2);

Si la asignación lanza una excepción, el contenedor seguirá conteniendo el valor; no se ha producido ninguna pérdida de datos.

Ten en cuenta que las clases de Qt compartidas implícitamente no lanzan excepciones en sus operadores de asignación ni en sus constructores de copia, por lo que la limitación anterior no se aplica.

Gestión del agotamiento de memoria

La mayoría de los sistemas operativos de escritorio sobreasignan memoria. Esto significa que malloc() o operator new devuelven un puntero válido, aunque no haya suficiente memoria disponible en el momento de la asignación. En dichos sistemas, no se lanza ninguna excepción de tipo std::bad_alloc.

En el resto de sistemas operativos, Qt lanzará una excepción de tipo std::bad_alloc si falla alguna asignación. Las asignaciones pueden fallar si el sistema se queda sin memoria o no dispone de suficiente memoria contigua para asignar el tamaño solicitado.

Las excepciones a esta regla están documentadas. Por ejemplo, los constructores de ` QImage ` crearán una imagen ` null ` si no hay memoria suficiente, en lugar de lanzar una excepción.

Recuperación tras excepciones

Actualmente, el único caso de uso admitido para la recuperación tras excepciones lanzadas dentro de Qt (por ejemplo, debido a falta de memoria) consiste en salir del bucle de eventos y realizar algunas tareas de limpieza antes de cerrar la aplicación.

Caso de uso típico:

QApplication app(argc, argv);
...
int ret;
try {
    ret = app.exec();
} catch (const std::bad_alloc &) {
    // clean up here, e.g. save the session
    // and close all config files.

    return EXIT_FAILURE; // exit the application
}
...
return ret;

Tras lanzarse una excepción, es posible que la conexión con el servidor de ventanas ya se haya cerrado. No es seguro llamar a una función relacionada con la interfaz gráfica de usuario tras capturar una excepción.

Excepciones en el código del cliente

Señales y ranuras

Lanzar una excepción desde una ranura invocada por el mecanismo de conexión de señales y ranuras de Qt se considera un comportamiento indefinido, a menos que se gestione dentro de la propia ranura:

State state;
StateListener stateListener;

// OK; the exception is handled before it leaves the slot.
QObject::connect(&state, SIGNAL(stateChanged()), &stateListener, SLOT(throwHandledException()));
// Undefined behaviour; upon invocation of the slot, the exception will be propagated to the
// point of emission, unwinding the stack of the Qt code (which is not guaranteed to be exception safe).
QObject::connect(&state, SIGNAL(stateChanged()), &stateListener, SLOT(throwUnhandledException()));

Si la ranura se invocó directamente, como una llamada a una función normal, se pueden utilizar excepciones. Esto se debe a que, al invocar las ranuras directamente, se omite el mecanismo de conexión:

State state;
StateListener stateListener;

// ...

try {
    // Correcto; invocación directa de la ranura.
    stateListener.throwException();
} catch (...) {
    qDebug() << "Handling exception not caught in slot.";
}

© 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.