Exception Safety

Exception safety refers to the ability of code to correctly handle and recover from exceptions without leaving the program in an inconsistent or invalid state. Exception-safe code ensures that resources are properly managed, invariants are maintained, and the program remains in a well-defined state, even in the presence of exceptions.

There are three commonly recognized levels of exception safety:

1. Basic guarantee: If an exception is thrown, the program is left in a valid but unspecified state. No resources are leaked, and all invariants are preserved.
2. Strong guarantee: If an exception is thrown, the program state remains unchanged, as if the operation had never been attempted. This is also known as "commit or rollback" semantics.
3. No-throw guarantee: The operation is guaranteed not to throw any exceptions and always succeeds.

To ensure exception safety in your code, you can follow these guidelines:

• Use RAII (Resource Acquisition Is Initialization) techniques to manage resources. This involves wrapping resource acquisition and release in classes with constructors and destructors, ensuring automatic cleanup in case of exceptions.
• Use standard library containers and algorithms, which provide strong exception safety guarantees.
• Use smart pointers (e.g., std::unique_ptr, std::shared_ptr) to manage dynamically allocated memory and avoid manual memory management.
• Avoid throwing exceptions from destructors, as they may lead to unexpected behavior and resource leaks.
• Use the "copy and swap" idiom for assignment operators to provide strong exception safety.
• Use noexcept specifiers to indicate functions that are guaranteed not to throw exceptions.
• Handle exceptions at the appropriate level of abstraction and avoid letting exceptions propagate uncontrolled.

Here's an example of exception-safe code using RAII:

1#include <iostream>
2#include <memory>
3
4class Resource {
5 public:
6  Resource() {
7    std::cout << "Acquiring resource\n";
8  }
9  ~Resource() {
10    std::cout << "Releasing resource\n";
11  }
12};
13
14void foo() {
15  std::unique_ptr<Resource> resource{
16    std::make_unique<Resource>()};
17
18  // Use the resource
19  throw std::runtime_error("Exception occurred");
20}
21
22int main() {
23  try {
24    foo();
25  } catch (const std::exception& ex) {
26    std::cout << "Caught exception: "
27      << ex.what();
28  }
29}

1Acquiring resource
2Releasing resource
3Caught exception: Exception occurred

In this example, the Resource class represents a resource that needs to be acquired and released. The std::unique_ptr is used to manage the lifetime of the resource. Even if an exception is thrown within the foo() function, the destructor of Resource will be called automatically when the std::unique_ptr goes out of scope, ensuring proper cleanup and preventing resource leaks.

By following exception safety principles and using appropriate techniques like RAII and smart pointers, you can write robust and exception-safe code in C++.