Implementing finally in C++

Did you hear about the “finally” concept in Java? Are you wondering why it is not present in C++?

The below article is for you. We will discuss what is “finally” in Java, how to implement it in C++, the advantages of “finally”, and what is present in C++ for this concept.

Introduction to the “finally” concept in Java

In Java, the “finally” block is a code section that follows the try and/or catch blocks in exception handling. The “finally” block is executed irrespective of whether an exception occurs. This block ensures that critical resources, like files, network connections, or database connections, are correctly closed or released regardless of whether an exception is thrown.

Here is an example of how to use the “finally” block in Java.

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 2; // This line will not cause an exception
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Exception: " + e.getMessage());
        } finally {
            System.out.println("This line will always be executed.");
        }
    }
}

In this example, the try block contains code that may throw an exception (although it doesn’t work in this case). The catch block would handle any ArithmeticException that occurs. 

Regardless of whether an exception is thrown, the code in the “finally” block will always be executed.

It is important to note that if there’s a return statement in the try or catch block, the “finally” block will still be executed before the method returns.

How to implement in C++?

C++ does not have a built-in “finally” concept like Java. Still, you can achieve similar functionality using RAII (Resource Acquisition Is Initialization) or a custom Finally class combined with lambda functions.

Here’s an example using a custom Finally class and a lambda. The program can be downloaded at https://github.com/codeversionmaster/cplusplus/blob/cplusplus17/projects/finally.cpp.

#include <iostream>
#include <stdexcept>
#include <functional>

class Finally {
public:
    Finally(std::function<void()> func) : m_func(func) {}
    ~Finally() { m_func(); }

private:
    std::function<void()> m_func;
};

int main() {
    try {
        Finally onExit([] { std::cout << "This line will always be executed." << std::endl; });

        int numerator = 10;
        int denominator = 0;

        if (denominator == 0) {
            throw std::runtime_error("Division by zero");
        }

        int result = numerator / denominator;
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception &e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }

    return 0;
}

In this example, we define a Finally class that takes a lambda function in its constructor. The lambda function is executed when the “finally” object is destroyed. 

This ensures that the lambda function is always called, regardless of whether an exception occurs, which is similar to the behavior of the “finally” block in Java.

The compilation and execution output is below.

$ g++ -o finally finally.cpp

$ ./finally 
This line will always be executed.
Exception: Division by zero

Advantages of the “finally” concept

The finally block, a concept in languages like Java and C#, is particularly useful in scenarios where specific actions need to be executed regardless of whether an exception is thrown. Some common scenarios where finally is beneficial include:

  1. Resource Management: In many programming tasks, resources like file handles, network sockets, or database connections need to be acquired and released properly. The finally block ensures that these resources are released even if an exception is thrown during execution, preventing resource leaks and maintaining the stability of the system.
  2. Transaction Management: In database programming, operations are often organized into transactions. A transaction should be either committed or rolled back, depending on whether the operations succeed or fail. The “finally” block can be used to guarantee that a transaction is correctly finalized, regardless of the occurrence of an exception.
  3. Lock Management: In concurrent programming, shared resources are often protected by locks to ensure correct synchronization among threads. Acquiring and releasing a lock is crucial to avoid deadlocks and maintain consistency. Using a “finally” block can help ensure that locks are always released, even in the presence of exceptions.
  4. Clean-up Actions: There are cases where certain clean-up actions need to be performed after executing a block of code, such as deleting temporary files, clearing caches, or resetting shared variables. The “finally” block guarantees that these actions are executed, whether or not an exception occurs.
  5. Logging and Auditing: In enterprise applications, logging and auditing are essential for tracking system behavior and diagnosing issues. The “finally” block can be used to ensure that log entries or audit records are written, even if an exception occurs during processing.
  6. Code Maintainability: The “finally” block helps in separating error-handling code from the main logic, which can improve code maintainability. By placing clean-up actions in the “finally” block, developers can ensure that these actions are not accidentally omitted or duplicated across multiple catch blocks.
  7. Consistent Execution Flow: The “finally” block provides a single point of exit for a try-catch structure, making it easier to reason about the code flow. It helps to ensure that certain actions are always executed, even if the control flow is altered due to exceptions or return statements.

What does C++ have equivalent to “finally”?

C++ does not have a built-in finally feature like Java because it relies on a different programming paradigm called RAII (Resource Acquisition Is Initialization) for handling resource management and clean-up operations. 

RAII is a technique in which resource acquisition and release are tied to the lifetime of an object. When an object is created, it acquires the necessary resources, and when the object goes out of scope or is destroyed, it automatically releases those resources.

RAII provides the following advantages over a “finally” block:

  1. Automatic Resource Management: In C++, resources are automatically released when an object goes out of scope, even with exceptions. This eliminates the need for an explicit “finally” block to handle clean-up operations.
  2. Exception Safety: RAII helps to write exception-safe code, as resources are guaranteed to be released regardless of how control leaves the current scope. This ensures that no resource leaks occur when an exception is thrown.
  3. Less Error-Prone: With RAII, it is less likely for a developer to forget to release resources or clean up, as the object’s destructor takes care of these tasks automatically. This leads to more robust and maintainable code.
  4. Simpler Syntax: Using RAII, the syntax for handling resources and clean-up operations is often simpler than using a try-catch-finally structure, as it avoids the need for additional control-flow constructs.

While RAII is a powerful technique in C++, it is important to note that some languages, like Java, do not support destructors in the same way as C++ does. Instead, they rely on garbage collection for memory management and provide the “finally” block as an alternative mechanism for handling resource clean-up.

In conclusion, C++ does not have an in-built finally feature because it relies on the RAII paradigm for resource management and clean-up operations, which provides a more automatic and less error-prone approach compared to the “finally” block.