Exception handling in C++ – developers are wary
As I mentioned last week, I am very much in “C++ mode” just now, mainly because I am preparing for some online classes. As a result of various social media contacts, I am getting some interesting impressions of how C++ is viewed among embedded developers. There is certainly much controversy. Some developers love it, but many are very critical.
Various aspects of the language concern engineers, and a particular one is exception handling …
The Exception Handling System [EHS] in C++ has nothing to be with exceptions in the sense of being hardware interrupts. It is designed to handle exceptional situations that are detected by the software. The intention is to provide a controlled failure mode, where a smooth exit from some deeply nested function calls is required [without resorting to goto].
The use of EHS is quite straightforward. Code that needs EHS activated during its execution is enclosed in a try block. A throw statement is used to assert an exception, which is identified by means of a class. Processing of the exception is performed by some code in a catch block. There is normally one catch block for each type of exception that may be asserted.
This seems quite neat and simple and does provide a way to write fairly readable code in which exception handling is needed. However, there are some key points that should make embedded developers wary:
- If you are going to use the EHS, the additional code much be incorporated [a compiler option] for the entire application. It is not obvious to the human reader [or the compiler] what functions might be called [indirectly] by the code in a try block. This additional code adds size and reduces execution performance.
- Many compilers default to including EHS code. This means that the unwitting user incorporates the overhead automatically, even if they have no intention of using the EHS. A compiler switch is normally available to activate or deactivate the EHS code generation.
- If you application’s exception handling needs are simple, there are two ways to deploy the EHS which reduce the overheads:
- Use a generic catch block [where the type is specified with “…”] instead of one for each type of exception.
- Do not include any catch blocks. This results in the library function terminate() being called when an exception is thrown. This function can be customized.
Personally, I would shy away from using EHS, but, used with care, it may be beneficial to many designs. The overhead should be carefully measured.
Posted May 12th, 2014, by Colin Walls
- What size drink would you like?
- Using an embedded Web server
- Row 13 – unlucky for some?
- Brillo – a brilliant OS or a scouring pad?
- How Mac and I are getting along – an interim report
- IPv6 – some guidance to the uninitiated
- Power outlets when traveling – and USB again
- Spotting the difference – subtleties of C code
- Shutting the Windows – moving to a Mac?
- DAC and Embedded TechCon – embedded and EDA coming together?