C++ Exceptions

What are exceptions?

• Exception was a new error handling pattern that was introduced to C++ at the beginning of the language (C++98) and has been evolving ever since.

• The basic code structure for using exception involves three parts
• One try block
• One or more catch blocks
• One or more throw statements

• It is best to look at an example first exception_demo.cpp

#include <iostream>

using namespace std;

int main()
{
    try
    {
        throw 20;
    }
    catch (int e)
    {
        cout << "An exception occurred. Exception #" << e << '\n';
    }
    return 0;
}

• Note that the catch (int e) statement looks a lot like function definition that, which in this case, takes an integer as an argument.

• In this sense, throw looks a lot like return as well. The throw statement gives control back to anther function and with it, a variable gets passed.

• For built-in types like int and char, it is common to pass them by value. For more complex types such as class objects, it is generally more suitable to pass them by reference.

• Here is another example throwing objects exception_ojbect.cpp

#include <iostream>
#include <exception>
#include <string>

using namespace std;

class MyException : public exception
{
private:
    string value;

public:
    MyException(int v) { value = to_string(v); }
    const char *what() { return value.c_str(); }
};

int main()
{
    try
    {
        throw MyException(20);
    }
    catch (MyException &e)
    {
        cout << "An exception occurred. Exception Nr. " << e.what() << '\n';
    }
    return 0;
}

• Even though we are catching a reference to an object of the MyException type, it is actually a copy of the original object being thrown.

• The reason to use a reference is that, a base-class reference can also refer to derived-class objects. Say you have a collection of exception objects, each is thrown at different circumstances. You can then catch them all with a reference to the base exception type.

class BaseException { ... };
class Case1Exception : public BaseException { ... };
class Case2Exception : public BaseException { ... };

void my_function()
{
    ...
    if (case1) throw Case1Exception();
    if (case2) throw Case2Exception();
		...
}

int main()
{
    ...
    try
    {
        my_function();
    }
    catch (BaseException &be)
    {
        ...
    }
    ....
    return 0;
}

Exceptions specification in functions

#include <iostream>

// A function with an exception specification using throw()
void foo() throw(int)
{
    int x = 0;
    if (x == 0)
    {
        throw 42; // This is allowed because we specified throw(int)
    }
}

int main()
{
    try
    {
        foo();
    }
    catch (int e)
    {
        std::cerr << "Caught an exception: " << e << std::endl;
    }
    return 0;
}

void foo() noexcept;          // foo will not throw any exception
void bar() noexcept(false);   // bar is allowed to throw an exception

Altering the default behavior

• An exception escapes a function marked noexcept

• An exception is thrown while another one is still in flight, e.g. a destructor throws during stack unwinding

• throw; is used to re-throw when no exception is being handled

#include <iostream>
#include <stdexcept>

void foo() noexcept
{
    throw std::runtime_error("I promised I wouldn't");
}

int main()
{
    try
    {
        foo();
    }
    catch (const std::exception &e)
    {
        // never reached: std::terminate() is called before we get here
        std::cout << "caught: " << e.what() << '\n';
    }
    return 0;
}

terminate called after throwing an instance of 'std::runtime_error'
  what():  I promised I wouldn't
Aborted (core dumped)

#include <cstdlib>
#include <exception>
#include <iostream>
#include <stdexcept>

void my_terminate()
{
    // find out what was thrown, if anything
    if (std::exception_ptr ep = std::current_exception())
    {
        try
        {
            std::rethrow_exception(ep);
        }
        catch (const std::exception &e)
        {
            std::cerr << "uncaught exception: " << e.what() << '\n';
        }
        catch (...)
        {
            std::cerr << "uncaught exception of unknown type\n";
        }
    }
    std::abort();
}

int main()
{
    std::set_terminate(my_terminate);
    throw std::runtime_error("nobody catches me");
}

uncaught exception: nobody catches me
Aborted (core dumped)

Working with dynamic memory allocation

new throws too

#include <iostream>
#include <new>

int main()
{
    // ask for 1 PiB, more than any machine has
    const std::size_t huge = 1ULL << 50;

    try
    {
        char *p = new char[huge];
        delete[] p;
    }
    catch (const std::bad_alloc &e)
    {
        std::cout << "new failed: " << e.what() << '\n';
    }

    // the nothrow version returns nullptr instead of throwing
    char *q = new (std::nothrow) char[huge];
    if (q == nullptr)
    {
        std::cout << "new (std::nothrow) returned nullptr\n";
    }
    delete[] q;
    return 0;
}

new failed: std::bad_alloc
new (std::nothrow) returned nullptr

Exceptions and memory leaks

#include <iostream>
#include <memory>
#include <stdexcept>

struct Buffer
{
    Buffer() { std::cout << "Buffer acquired\n"; }
    ~Buffer() { std::cout << "Buffer released\n"; }
};

void process(Buffer *)
{
    throw std::runtime_error("processing failed");
}

void leaky()
{
    Buffer *buf = new Buffer();
    process(buf); // throws
    delete buf;   // never reached, buf is leaked
}

void safe()
{
    std::unique_ptr<Buffer> buf(new Buffer());
    process(buf.get()); // throws
} // buf's destructor runs during stack unwinding

int main()
{
    try { leaky(); } catch (const std::exception &e) { std::cout << "leaky(): " << e.what() << "\n\n"; }
    try { safe(); } catch (const std::exception &e) { std::cout << "safe(): " << e.what() << '\n'; }
    return 0;
}

Buffer acquired
leaky(): processing failed

Buffer acquired
Buffer released
safe(): processing failed

• If a constructor throws inside a new expression, the memory is freed automatically, and the members that were already constructed are destroyed. The object's own destructor does not run, because the object was never fully constructed.

• Don't let exceptions escape destructors. Destructors run during stack unwinding, and throwing while another exception is in flight calls std::terminate(). Since C++11, destructors are implicitly noexcept anyway, so a throwing destructor ends the program even outside of unwinding.

References

• Wikipedia page on Exception handling (programming)

• std::terminate on cppreference

• std::set_terminate on cppreference

• RAII on cppreference