Containers
Qt's container classes are generally exception neutral. They pass any exception that happens within their contained type T to the user while keeping their internal state valid.
Example:
QList<QString> list;
...
try {
list.append("hello");
} catch (...) {
}
Exceptions to that rule are containers for types that can throw during assignment or copy constructions. For those types, functions that modify the container as well as returning a value, are unsafe to use:
MyType s = list.takeAt(2);
If an exception occurs during the assignment of s, the value at index 2 is already removed from the container, but hasn't been assigned to s yet. It is lost without chance of recovery.
The correct way to write it:
MyType s = list.at(2);
list.removeAt(2);
If the assignment throws, the container still contains the value, no data loss occured.
Note that implicitly shared Qt classes will not throw in their assignment operators or copy constructors, so the limitation above does not apply.
Out of Memory Handling
Most desktop operating systems overcommit memory. This means that malloc() or operator new return a valid pointer, even though there is not enough memory available at allocation time. On such systems, no exception of type std::bad_alloc is thrown.
On all other operating systems, Qt will throw an exception of type std::bad_alloc if any allocation fails. Allocations can fail if the system runs out of memory or doesn't have enough continuous memory to allocate the requested size.
Exceptions to that rule are documented. As an example, QImage::create() returns false if not enough memory exists instead of throwing an exception.
Recovering from exceptions
Currently, the only supported use case for recovering from exceptions thrown within Qt (for example due to out of memory) is to exit the event loop and do some cleanup before exiting the application.
Typical use case:
QApplication app(argc, argv);
...
try {
app.exec();
} catch (const std::bad_alloc &) {
return 0;
}
After an exception is thrown, the connection to the windowing server might already be closed. It is not safe to call a GUI related function after catching an exception.
Platform-Specific Exception Handling
The Symbian platform
The Symbian platform implements its own exception system that differs from the standard C++ mechanism. When using Qt for the Symbian platform, and especially when writing code to access Symbian functionality directly, it may be necessary to know about the underlying implementation and how it interacts with Qt.
The Exception Safety with Symbian document shows how to use the facilities provided by Qt to use exceptions as safely as possible.
