...
Based on the effects mentioned above we can distinguish among three kinds of exception safety guarantees in decreasing desirability:
Guarantee | Description | Example |
|---|---|---|
Strong | The strong exception safety guarantee is a property of an operation such that, in addition to satisfying the basic exception safety guarantee, if the operation terminates by raising an exception it has no observable effects on program state. (See strong exception safety.) | |
Basic | The basic exception safety guarantee is a property of an operation such that, if the operation terminates by raising an exception, it preserves program state invariants and prevents resource leaks. (See basic exception safety.) | |
None | Code that provides neither the strong nor the basic exception safety guarantee is not exception safe. |
Code that provides no exception safety guarantee is unsafe and must be considered defective.
| Anchor | ||||
|---|---|---|---|---|
|
Non-Compliant Code Example
...
(No Exception Safety)
The following noncompliant example shows a flawed implementation of the copy assignment operator of a dynamically sizable array class. The implicit invariants of the class are that the array member is a valid (possibly null) pointer and that the nelems member stores the number of elements in the array pointed to by array.
The copy assignment operator is flawed because it fails to provide any exception safety guarantee. The function deallocates array and assigns the element counter, nelems, before allocating a new block of memory for the copy. As a result, when the new expression throws an exception, the function will have modified the state of both member variables in a way that violates the implicit invariants of the class. Consequently, the object of the class is in an indeterminate state and any operation on it, including its destruction, results in undefined behavior.
| Code Block | ||
|---|---|---|
| ||
class IntArray {
int *array;
std::size_t nelems;
public:
// ...
~IntArray() {
delete[] array;
}
IntArray& operator=(const IntArray &rhs) {
if (this != &rhs) {
delete[] array;
nelems = rhs.nelems;
array = new int[nelems];
std::memcpy(array, rhs.array, nelems * sizeof *array);
}
return *this;
}
// ...
};
|
| Anchor | ||||
|---|---|---|---|---|
|
Compliant Solution (Strong Exception Safety)
In the compliant solution below, the copy assignment operator provides the Strong Exception Safety guarantee. The function takes care to allocate new storage for the copy before changing the state of the object. Only after the allocation succeeds does the function proceed to change the state of the object. In addition, by copying the array to the newly allocated storage before deallocating the existing array the function avoids the test for self-assignment, thus improving the performance of the code in the common case.
| Code Block | ||
|---|---|---|
| ||
class IntArray {
int *array;
std::size_t nelems;
public:
// ...
~IntArray() {
delete[] array;
}
IntArray& operator=(const IntArray &rhs) {
int* const tmp = new int[rhs.nelems];
std::memcpy(tmp, rhs.array, nelems * sizeof *array);
delete[] array;
array = tmp;
nelems = rhs.nelems;
return *this;
}
// ...
};
|
TO DO
...
| bgColor | #FFcccc |
|---|
Compliant Solution
TO DO
| Code Block | |
|---|---|
| bgColor | #ccccff
Risk Assessment
Code that is not exception safe typically leads to resource leaks, causes the program to be left in an inconsistent or unexpected state, and ultimately results in undefined behavior at some point after the first exception is thrown.
...