Exception safety with std::stack

Yes, std::stack is designed to be exception-safe. The C++ Standard Library guarantees that all operations on std::stack either succeed completely or have no effect if an exception is thrown. This is known as the strong exception guarantee.

Let's look at what this means for some common operations:

1. push() or emplace(): If an exception is thrown during the insertion of a new element (either due to a copy/move operation or due to the container running out of memory), the stack remains unchanged. The element is not added, and any elements previously in the stack are still present and unchanged.
2. pop(): If an exception is thrown during the removal of the top element, the element is still removed. No elements are left in an invalid or unspecified state.

Here's an example:

1#include <iostream>
2#include <stack>
3
4class MyClass {
5 public:
6  MyClass(int id) : id(id) {
7    if (id == 4) {
8      throw std::runtime_error(
9        "Cannot copy MyClass with id 2");
10    }
11  }
12
13  int id;
14};
15
16int main() {
17  std::stack<MyClass> s;
18
19  try {
20    s.emplace(1);
21    s.emplace(2);
22    s.emplace(3);
23    s.emplace(4);  // this will throw
24  } catch (...) {
25    std::cout << "Exception caught! stack size: "
26      << s.size() << '\n';
27  }
28
29  // The stack is still in a valid state
30  while (!s.empty()) {
31    std::cout << s.top().id << ' ';
32    s.pop();
33  }
34}

1Exception caught! stack size: 3
23 2 1

In this code, when the stack tries to copy an instance of MyClass with id 2, an exception is thrown. However, the stack remains in a valid state. The element with id 1, which was previously inserted successfully, is still present and can be accessed normally.

The strong exception guarantee is an important property that allows you to write robust, error-resistant code. It means that if an exception is thrown, you don't need to worry about your stack being left in an inconsistent or corrupted state.