{"id":1952,"date":"2025-01-26T20:40:10","date_gmt":"2025-01-26T20:40:10","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=1952"},"modified":"2025-01-27T18:35:04","modified_gmt":"2025-01-27T18:35:04","slug":"c-exceptions","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/exceptions-2\/c-exceptions\/","title":{"rendered":"C++ Exceptions"},"content":{"rendered":"\n

<\/span>C++ Exceptions<\/span><\/h2>\n\n\n\n

In C++:<\/p>\n\n\n\n

    \n
  • Exceptions are built into the language, not added on via macros.<\/li>\n\n\n\n
  • In C++, raising an exception is known as throw<\/code><\/strong>ing an exception.<\/li>\n\n\n\n
  • There is no special exception declaration;  you can throw<\/strong> any type (but it’s useful to have specific exception classes).<\/li>\n<\/ul>\n\n\n\n

    For example:<\/p>\n\n\n\n

    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Rational.h<\/span><\/span>\n\/\/  C++ Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Rational_h<\/span><\/span>\n#define<\/span> Rational_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Rational<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/\/ Nested class<\/span><\/span>\n  <\/span>class<\/span> <\/span>ZeroDenominatorException<\/span><\/span>\n  {};<\/span><\/span>\n<\/span>\n  <\/span>Rational<\/span>(<\/span>int<\/span> <\/span>numerator<\/span> = <\/span>0<\/span>, <\/span>int<\/span> <\/span>denominator<\/span> = <\/span>1<\/span>)<\/span><\/span>\n    : <\/span>m_num<\/span>(numerator), <\/span>m_den<\/span>(denominator)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (denominator == <\/span>0<\/span>)<\/span><\/span>\n      <\/span>throw<\/span> <\/span>ZeroDenominatorException<\/span>();<\/span><\/span>\n    <\/span>Normalize<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>void<\/span> <\/span>Normalize<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> m_num, m_den;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Rational_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Rational.cpp<\/span><\/span>\n\/\/  C++ Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Rational.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Rational<\/span>::<\/span>Normalize<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Pretend to normalize the rational<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  C++ Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Rational.h"<\/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  Rational <\/span>r<\/span>(<\/span>4<\/span>, <\/span>0<\/span>);<\/span><\/span>\n    \/\/ Exception occurs! What happens?<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Here’s what happens;<\/p>\n\n\n\n
    libc++abi: terminating due to uncaught exception of type Rational::ZeroDenominatorException<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Catching Exceptions<\/span><\/h3>\n\n\n\n
    Handling an exception is known in C++ as catch<\/strong><\/code>ing an exception.<\/p>\n\n\n\n
    The TRY<\/code><\/strong> in the C pseudo-exception handling becomes try<\/code><\/strong> in C++.  <\/p>\n\n\n\n
    For example:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  C++ Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Rational.h"<\/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    Rational <\/span>r<\/span>(<\/span>4<\/span>, <\/span>0<\/span>);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (<\/span>Rational<\/span>::ZeroDenominatorException e)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"Caught a ZeroDenominatorException"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>return<\/span> <\/span>1<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Now, the program outputs:<\/p>\n\n\n\n
    Caught a ZeroDenominatorException\nProgram ended with exit code: 1<\/code><\/pre>\n\n\n\n
    The catch<\/code><\/strong> construct is called an exception handler<\/em> (or sometimes a catch<\/code><\/strong> handler<\/em>)<\/p>\n<\/div>\n<\/div>\n\n\n\n
    A try<\/strong> block may contain several exception handlers, to catch<\/strong> more than one kind of exception:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    try<\/span><\/span>\n{<\/span><\/span>\n\t\/* statements... *\/<\/span><\/span>\n}<\/span><\/span>\ncatch<\/span>(<\/span>Rational<\/span>::ZeroDenominatorException e)<\/span><\/span>\n{<\/span><\/span>\n\t\/* statements... *\/<\/span><\/span>\n}<\/span><\/span>\ncatch<\/span>(<\/span>Vector<\/span>::OutOfRangeException e)<\/span><\/span>\n{<\/span><\/span>\n\t\/* statements... *\/<\/span><\/span>\n}<\/span><\/span>\ncatch<\/span>(SomeOtherExceptionType e)<\/span><\/span>\n{<\/span><\/span>\n\t\/* statements... *\/<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    <\/div>\n<\/div>\n\n\n\n
    <\/span>Throwing Exceptions<\/span><\/h3>\n\n\n\n
    When an exception is thrown, the call stack is searched, from the throw<\/code><\/strong> point up through its callers, for an exception handler that handles the type of the exception being thrown.<\/p>\n\n\n\n
    If a matching exception handler is found, the call stack is “unwound” to the stack frame of the function that contains that handler, and destructors for local objects on each intervening stack frame are invoked along the way.<\/em><\/p>\n\n\n\n
    If a function throws an exception for which there is no matching exception handler on the call chain leading to the function throwing the exception, the default action is to terminate the program.<\/p>\n\n\n\n
    Once a handler has caught an exception, that exception is considered dealt with, and the presence of other handlers that might handle this exception becomes irrelevant.  <\/p>\n\n\n\n
    For example:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Try<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/23\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Vector<\/span><\/span>\n{<\/span><\/span>\n  \/\/ ...<\/span><\/span>\npublic:<\/span> <\/span>class<\/span> <\/span>Range<\/span> {};<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>DoSomethingSafely<\/span>(<\/span>Vector<\/span>&<\/span> <\/span>vector<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span> {<\/span><\/span>\n    \/\/ do work on the Vector...<\/span><\/span>\n    <\/span>throw<\/span> <\/span>Vector<\/span>::<\/span>Range<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (<\/span>Vector<\/span>::Range r) <\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::clog << <\/span>"Caught Vector::Range exception "<\/span><\/span>\n              << <\/span>"in DoSomethingSafely()"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>BeSure<\/span>(<\/span>Vector<\/span> <\/span>&<\/span>v<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span> <\/span><\/span>\n  {<\/span><\/span>\n    <\/span>DoSomethingSafely<\/span>(v);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (<\/span>Vector<\/span>::Range r)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::clog << <\/span>"Caught Vector::Range exception "<\/span><\/span>\n              << <\/span>"in BeSure()"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/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  Vector v;<\/span><\/span>\n  <\/span>BeSure<\/span>(v);<\/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
    The exception handler in the BeSure<\/strong><\/code> function will never be invoked, because the function DoSomethingSafely<\/strong><\/code> will always catch the Vector::Range<\/strong><\/code> exception.<\/p>\n\n\n\n
    The program outputs:<\/p>\n\n\n\n
    Caught Vector::Range exception in DoSomethingSafely()\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Discrimination of Exceptions<\/span><\/h3>\n\n\n\n
    Once a handler has completed its work, the next statement following all the catch<\/code><\/strong> handlers for the try<\/code><\/strong> block is executed:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    cout << <\/span>"Something "<\/span>;<\/span><\/span>\ntry<\/span><\/span>\n{<\/span><\/span>\n  <\/span>doSomething<\/span>(v);<\/span><\/span>\n  cout << <\/span>"good "<\/span>;<\/span><\/span>\n}<\/span><\/span>\ncatch<\/span>(<\/span>Vector<\/span>::Range)<\/span><\/span>\n{<\/span><\/span>\n  cout << <\/span>"strange "<\/span>;<\/span><\/span>\n}<\/span><\/span>\ncatch<\/span>(<\/span>Vector<\/span>::Size)<\/span><\/span>\n{<\/span><\/span>\n  cout << <\/span>"weird "<\/span><\/span>\n}<\/span><\/span>\ncout << <\/span>"happened"<\/span> << endl;<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    <\/div>\n<\/div>\n\n\n\n
    An exception is considered “handled”<\/em> immediately upon entry into its handler.  Thus, any exceptions thrown while executing a handler must be dealt with by callers of the try block.  <\/p>\n\n\n\n
    For example:<\/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> (InputOverFlow)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n  <\/span>throw<\/span> <\/span>InputOverFlow<\/span>();<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    does not<\/em> cause an infinite loop.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    Exception handlers may be nested:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    try<\/span><\/span>\n{<\/span><\/span>\n  \/\/ something...<\/span><\/span>\n}<\/span><\/span>\ncatch<\/span> (NumericOverflow)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>try<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ something complicated...<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span> (BathOverflow)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ get wet...<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    But:<\/p>\n\n\n\n
    \n
    “such nesting is rarely useful in human-written code, and is more often than not an indication of poor style”<\/em><\/p>\n\n\n\n
    Bjarne Stroustrup, The C++ Programming Language, 3rd Edition<\/em><\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Naming of Exceptions<\/span><\/h3>\n\n\n\n
    An exception is caught by specifying its type<\/em>.<\/p>\n\n\n\n
    However, what is thrown is not a type, but an object<\/em>.  If we need to convey information from the throw point to the handler, we can do so by putting data into the object thrown.<\/p>\n\n\n\n
    To examine this data, the handler must give a name to the exception object:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    try<\/span> <\/span><\/span>\n{ <\/span><\/span>\n  <\/span>doSomething<\/span>(v); <\/span><\/span>\n}<\/span><\/span>\ncatch<\/span> (<\/span>Vector<\/span>::Range r)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cerr << <\/span>"Bad index "<\/span> << <\/span>r<\/span>.<\/span>getIndex<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    The construct after the catch: catch (Vector::Range r)<\/code><\/strong> is a declaration, similar to a formal argument declaration for a function.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    Here’s an example:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  Vector.h<\/span><\/span>\n\/\/  Naming Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Vector_h<\/span><\/span>\n#define<\/span> Vector_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Vector<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>class<\/span> <\/span>OutOfRange<\/span><\/span>\n  {<\/span><\/span>\n  <\/span>public:<\/span><\/span>\n    <\/span>OutOfRange<\/span>(<\/span>int<\/span> <\/span>index<\/span>) <\/span><\/span>\n      : <\/span>m_index<\/span>(index)<\/span><\/span>\n    {}<\/span><\/span>\n    <\/span><\/span>\n    <\/span>int<\/span> <\/span>getIndex<\/span>() { <\/span>return<\/span> m_index; }<\/span><\/span>\n    <\/span><\/span>\n  <\/span>private:<\/span><\/span>\n    <\/span>int<\/span> m_index;<\/span><\/span>\n  };<\/span><\/span>\n  <\/span><\/span>\n  <\/span>Vector<\/span>(<\/span>size_t<\/span> <\/span>size<\/span>)<\/span><\/span>\n    : <\/span>m_data<\/span>( <\/span>new<\/span> <\/span>int<\/span>[size] ), <\/span>m_size<\/span>(size)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ Initialize each array element<\/span><\/span>\n    \/\/ with the square of its index.<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < size; i++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>m_data<\/span>[i] = i * i;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>~Vector<\/span>()<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (m_data != <\/span>NULL<\/span>)<\/span><\/span>\n      <\/span>delete[]<\/span> m_data;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"Vector contains: "<\/span><\/span>\n              << m_size << <\/span>" elements"<\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> i; i < m_size; i++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>std<\/span>::cout << <\/span>"["<\/span> << i << <\/span>"]"<\/span><\/span>\n                << <\/span>m_data<\/span>[i] << <\/span>std<\/span>::endl;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> <\/span>&<\/span>operator[]<\/span>(<\/span>int<\/span> <\/span>i<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (i < <\/span>0<\/span> || i >= m_size)<\/span><\/span>\n      <\/span>throw<\/span> <\/span>OutOfRange<\/span>(i);<\/span><\/span>\n    <\/span>return<\/span> <\/span>m_data<\/span>[i];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  \/\/ ...<\/span><\/span>\n  <\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> *m_data;<\/span><\/span>\n  <\/span>size_t<\/span> m_size;<\/span><\/span>\n  <\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Vector_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Naming Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 9\/24\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Vector.h"<\/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  Vector <\/span>v<\/span>(<\/span>20<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>v<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>try<\/span> <\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"Contents of [5] = "<\/span> << <\/span>v<\/span>[<\/span>5<\/span>] << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"Contents of [20] = "<\/span> << <\/span>v<\/span>[<\/span>20<\/span>] << <\/span>std<\/span>::endl;<\/span><\/span>\n  } <\/span><\/span>\n  <\/span>catch<\/span> (<\/span>Vector<\/span>::OutOfRange e)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"index OutOfRange: "<\/span><\/span>\n              << <\/span>e<\/span>.<\/span>getIndex<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Which outputs:<\/p>\n\n\n\n
    Vector contains: 20 elements\n[0]0\n[1]1\n[2]4\n[3]9\n[4]16\n[5]25\n[6]36\n[7]49\n[8]64\n[9]81\n[10]100\n[11]121\n[12]144\n[13]169\n[14]196\n[15]225\n[16]256\n[17]289\n[18]324\n[19]361\nContents of [5] = 25\nContents of [20] = index OutOfRange: 20\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/div>\n\n\n\n
    \n
    Next: Grouping of Exceptions<\/a><\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
    C++ Exceptions In C++: For example: Here’s what happens; Catching Exceptions Handling an exception is known in C++ as catching an exception. The TRY in the C pseudo-exception handling becomes try in C++.  For example: Now, the program outputs: The catch construct is called an exception handler (or sometimes a catch handler) A try block […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1928,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1952","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1952","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=1952"}],"version-history":[{"count":4,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1952\/revisions"}],"predecessor-version":[{"id":2016,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1952\/revisions\/2016"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1928"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=1952"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}