{"id":1963,"date":"2025-01-26T20:48:09","date_gmt":"2025-01-26T20:48:09","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=1963"},"modified":"2025-01-27T18:40:18","modified_gmt":"2025-01-27T18:40:18","slug":"grouping-of-exceptions","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/exceptions-2\/grouping-of-exceptions\/","title":{"rendered":"Grouping of Exceptions"},"content":{"rendered":"\n

<\/span>Grouping of Exceptions<\/span><\/h2>\n\n\n\n

Exceptions often fall naturally into families <\/em>or<\/em><\/strong> groups<\/em>.<\/p>\n\n\n\n

For example, consider a Matherr<\/code><\/strong> exception that might be thrown by a standard library of math functions.<\/p>\n\n\n\n

\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Grouping of Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\nenum<\/span> <\/span>Matherr<\/span> {<\/span>Overflow<\/span>, <\/span>Underflow<\/span>, <\/span>ZeroDivide<\/span>};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ ...<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (Matherr m)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>switch<\/span> (m)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>case<\/span> Overflow:<\/span> \/* ... *\/<\/span> <\/span>break<\/span>;<\/span><\/span>\n      <\/span>case<\/span> Underflow:<\/span> \/* ... *\/<\/span> <\/span>break<\/span>;<\/span><\/span>\n      <\/span>case<\/span> ZeroDivide:<\/span> \/* ... *\/<\/span> <\/span>break<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n    <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
but notice that this forces the handler to use a switch<\/code><\/strong> statement (or equivalent) to determine the actual exception thrown.<\/p>\n<\/div>\n<\/div>\n\n\n\n
This should be a familiar situation.  We have already encountered situations where such switch<\/code><\/strong> statements occurred, and were considered problematic.<\/p>\n\n\n\n
What did we use to solve this problem before?<\/p>\n\n\n\n
<\/span>Solution: Inheritance, and Virtual Functions!<\/span><\/h3>\n\n\n\n
It is possible to use inheritance and virtual functions to avoid the need for such a switch statement, and to improve the flexibility and maintainability of the code:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  GroupByInheritance.cpp<\/span><\/span>\n\/\/  Grouping of Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Matherr<\/span> {<\/span> \/* ... *\/<\/span> };<\/span><\/span>\nclass<\/span> <\/span>Overflow<\/span>: <\/span>public<\/span> <\/span>Matherr<\/span> {<\/span> \/* ... *\/<\/span> };<\/span><\/span>\nclass<\/span> <\/span>Underflow<\/span>: <\/span>public<\/span> <\/span>Matherr<\/span> {<\/span> \/* ... *\/<\/span> };<\/span><\/span>\nclass<\/span> <\/span>ZeroDivide<\/span>: <\/span>public<\/span> <\/span>Matherr<\/span> {<\/span> \/* ... *\/<\/span> };<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ ...<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (Overflow o)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ Handle Overflow or any subclass thereof...<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (Matherr m)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ Handle any other Matherr...<\/span><\/span>\n  }<\/span><\/span>\n    <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
We use the fact that several classes are subclasses of (derived from) Matherr<\/code><\/strong>, and inheritance takes care of things in the catch<\/code><\/strong> blocks.<\/p>\n<\/div>\n<\/div>\n\n\n\n
Organizing exceptions into such hierarchies can be important for code robustness.  To handle all exceptions from a class library, we would have to laboriously list each possible exception:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
try<\/span> <\/span><\/span>\n{ <\/span><\/span>\n  \/* ... *\/<\/span> <\/span><\/span>\n}<\/span><\/span>\ncatch<\/span> (Overflow) <\/span><\/span>\n{ <\/span><\/span>\n  \/* ... *\/<\/span> <\/span><\/span>\n}<\/span><\/span>\ncatch<\/span> (Underflow) <\/span><\/span>\n{ <\/span><\/span>\n  \/* ... *\/<\/span> <\/span><\/span>\n}<\/span><\/span>\ncatch<\/span> (ZeroDivide) <\/span><\/span>\n{ <\/span><\/span>\n  \/* ... *\/<\/span> <\/span><\/span>\n}<\/span><\/span>\n\/\/ ...<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
which is tedious and error-prone.<\/p>\n<\/div>\n<\/div>\n\n\n\n
Also, when a class library is augmented to use additional exceptions, every piece of code that uses the library must be modified to catch the new exceptions and then must be recompiled.  Such changes are made with great difficulty and reluctance.<\/p>\n\n\n\n
So, organizing exceptions into such hierarchies is a good approach, because it provides a mechanism to allow for library enhancement without the need for client code changes and recompilation.<\/p>\n\n\n\n
We can extend this to declare exceptions that are members of more than one ‘group’:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
class<\/span> <\/span>NetworkFileError<\/span>: <\/span>public<\/span> <\/span>NetworkError<\/span>,<\/span><\/span>\n                        <\/span>public<\/span> <\/span>FileSystemError<\/span><\/span>\n{ <\/span><\/span>\n  \/* ... *\/<\/span> <\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
<\/div>\n<\/div>\n\n\n\n
So, NetworkFileError<\/code><\/strong> exceptions can be caught by functions concerned with network exceptions:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
void<\/span> <\/span>NetFunction<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span> <\/span><\/span>\n  { <\/span><\/span>\n    \/* something *\/<\/span> <\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (NetworkError)<\/span><\/span>\n  { <\/span><\/span>\n    \/* ... *\/<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
and by functions dealing with file system exceptions:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
void<\/span> <\/span>FileSystemFunction<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span> <\/span><\/span>\n  { <\/span><\/span>\n    \/* something *\/<\/span> <\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (FileSystemError)<\/span><\/span>\n  { <\/span><\/span>\n    \/* ... *\/<\/span> <\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
This is important because services (such as networking) can be transparent, such that the writer of FileSystemFunction<\/code><\/strong> might not even be aware that the network might be involved.<\/p>\n\n\n\n
One could also make a policy of declaring a base class Exception<\/code><\/strong>, and deriving all exceptions from it.<\/p>\n\n\n\n
\n
There is indeed such a class (std::exception<\/strong>) in the C++ Standard Library.<\/p>\n\n\n\n
See here<\/a>.<\/p>\n<\/blockquote>\n\n\n\n
<\/span>Derived Exceptions<\/span><\/h3>\n\n\n\n
When using derived exceptions, the semantics for a handler catching and naming an exception are identical to that of a function accepting an argument.<\/p>\n\n\n\n