Customizing termination behavior for uncaught exceptions in C++

In this article, you will learn how to customize termination behaviour for uncaught exceptions in C++.

In C++, the std::set_terminate method allows an application to have a customized response when an uncaught exception occurs. It enables you to specify a unique handler that will be called if an unhandled exception causes the program to terminate.

The following are some thoughts about modifying C++ termination behavior for uncaught exceptions:

set_terminate (std::) Function: When an unhandled exception causes the terminate function to be invoked, you can use this function to set a custom termination handler that will be triggered.
Custom Termination Handler: You can establish a custom termination handler using std::set_terminate to specify a function that will be run when the program terminates due to an uncaught exception. Before the program ends, this handler can finish logging, cleaning up, or carrying out other essential duties.
std::terminate with Function: In the event of an unhandled exception, the runtime invokes the std::terminate function, which terminates the program by default using the std::abort. Instead of using the default termination, you can provide your action by customizing the termination behavior.
Exception Handling Policies: Customising the termination behavior for uncaught exceptions is especially helpful in cases where you need to set up particular protocols for dealing with exceptional circumstances. Some examples of these protocols include logging error data, releasing resources, or attempting graceful termination before the program terminates.
Flexibility and Control: You can specify policies and procedures that must be followed if an unhandled exception arises, giving you greater control over how the program handles extraordinary circumstances. You can also modify the termination behavior.
Exception Handling and Cleanup: You can ensure that any necessary cleanup or logging is done before the program stops by customizing the termination behavior. It is especially helpful when handling uncaught exceptions graciously.

The robustness and dependability of your code can be increased by using std::set_terminate to set a custom termination handler. It will ensure that your program handles certain tasks before they end because of unhandled exceptions.

Example:

Let us take an example to illustrate the std::set_terminate function in C++.

#include <iostream>
#include <exception>
#include <cstdlib>
void customTerminationHandler()
{
    std::cout << "Custom Termination Handler: Performing cleanup or other actions." << std::endl;
    // Before terminating, complete any necessary cleanup or other tasks.
    std::exit(EXIT_FAILURE); 
    // Terminate the program gracefully
}
int main() 
{
    // Setting the custom termination handler
    std::set_terminate(customTerminationHandler);
    try 
    {
        // Simulating an uncaught exception
        throw std::runtime_error("Custom uncaught exception occurred.");
    }
    catch (const std::exception& e)
    {
        // Catch the exception and handle it
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }
    // Other program logic or cleanup actions
    return 0;
}

Output:

Exception caught: Custom uncaught exception occurred.

Explanation:

1. Custom Termination Handler (customTerminationHandler function)

In this example, the customTerminationHandler method is used to create a custom termination handler.

You define this function as a unique termination handler. As a result of an unhandled exception, it is invoked just before the program ends.

To let you know that the custom termination handler is running, a message is printed inside the handler.

2. Main Function (main function)

In the main function, the std::set_terminate(customTerminationHandler) is used to set the custom termination handler. It links the program's termination owing to unhandled exceptions to the customTerminationHandler.

3. Catch-Try Block

An exception of type std::runtime_error is thrown inside the try block. Since there isn't a catch block that matches it that can deal with it directly, this exception remains uncaught.

The custom termination handler, the customTerminationHandler function, is triggered by the program when an unhandled exception occurs. The handler carries out its tasks, which include executing std::exit(EXIT_FAILURE) to end the program gently and printing a message.

4. Catch Block

It is not possible to catch the std::runtime_error exception. However, exceptions of type std::exception are captured in a generic catch block. Here, the exception's message (retrieved using e.what()) and a message stating that it was caught are printed.

5. Program Logic

Program logic or cleanup operations can proceed after the try-catch block. It appears from the "Other program logic or cleanup actions" comment that these actions won't be carried out in this particular example, though, since the program is ended by the custom termination handler.

Next TopicDifference between fill() and fill_n() functions in C++ STL

← prev next →