Using noexcept with move-only types

noexcept is particularly important when working with move-only types because it allows the move operations to be used safely and efficiently in various contexts, such as container operations and algorithm implementations.

Move-only types are types that cannot be copied but can be moved. Examples include std::unique_ptr, std::future, and types with move-only members. When a move operation (e.g., move constructor or move assignment operator) is not marked as noexcept, it indicates that the operation may throw an exception.

Here are a few reasons why noexcept is crucial for move-only types:

1. Container operations: Standard library containers like std::vector and std::deque use move operations when resizing or reallocating their internal storage. If the move constructor or move assignment operator of the contained type is not noexcept, the container will fall back to using copy operations instead, which is not possible for move-only types, resulting in a compilation error.
2. Algorithm implementations: Many standard library algorithms, such as std::sort and std::unique, use move operations to efficiently rearrange elements. If the move operations of the elements are not noexcept, the algorithms may fall back to less efficient copying or even fail to compile.
3. Exception safety: When a move operation is noexcept, it guarantees that no exceptions will be thrown during the move. This is important for maintaining exception safety and preventing resource leaks or inconsistent states in case an exception is thrown during a move operation.

Here's an example illustrating the importance of noexcept with move-only types:

1#include <iostream>
2#include <utility>
3#include <vector>
4
5class MoveOnlyType {
6 public:
7  MoveOnlyType() = default;
8  MoveOnlyType(const MoveOnlyType&) = delete;
9  MoveOnlyType& operator=(const MoveOnlyType&)
10    = delete;
11  MoveOnlyType(MoveOnlyType&&) noexcept = default;             
12  MoveOnlyType& operator=(MoveOnlyType&&) noexcept
13    = default;  
14};
15
16int main() {
17  std::vector<MoveOnlyType> vec;
18  vec.push_back(MoveOnlyType());
19  // Resizing the vector will use move operations
20  vec.resize(10);
21}

In this example, MoveOnlyType is a move-only type with deleted copy constructor and copy assignment operator. The move constructor and move assignment operator are marked as noexcept, allowing them to be used safely with containers like std::vector.

If the move operations were not noexcept, resizing the vector would fail to compile because the container would attempt to use copy operations as a fallback, which are not available for MoveOnlyType.