Why will move semantics not work with a move operator that is not marked as noexcept?

The move semantics in C++ are designed for efficient resource transfer from temporary objects. If the move operator (e.g., operator= or move constructor) is not marked as noexcept, the compiler cannot safely use it when automatically choosing between copying and moving in certain standard algorithms and containers (for example, when resizing std::vector).

The reason is as follows:

1. Exception guarantees: Standard containers and algorithms may provide strong exception guarantees (e.g., "no-throw guarantee" - not throwing exceptions under certain operations).
2. Rollback: In case an exception is thrown during the move of an element (for example, when moving an element to a new position in a vector that becomes invalid), the container must be able to revert to its original correct state.
3. Unsafe rollback when an exception occurs in the move operator: If the move operator throws an exception, the original object from which resources were transferred may end up in an undefined, partially moved, or invalid state. Safely rolling back such an operation by restoring the container's original state becomes impossible or very difficult.

When the move operator is marked as noexcept, the compiler knows that it will not throw an exception. This allows standard algorithms and containers to safely use move semantics, trusting that the operation will complete successfully and not compromise data integrity if a rollback is needed.

Without noexcept, even if the move operation does not actually throw exceptions, the compiler cannot guarantee this and is forced to choose copying (which usually provides stronger exception guarantees) to ensure container integrity in case of a potential exception.

Example:

#include <vector>
#include <iostream>

class Resource {
public:
    Resource() { data = new int[100]; std::cout << "Default ctor\n"; }
    ~Resource() { delete[] data; std::cout << "Dtor\n"; }

    // Copy constructor (may throw)
    Resource(const Resource& other) {
        data = new int[100]; // May throw std::bad_alloc
        std::copy(other.data, other.data + 100, data);
        std::cout << "Copy ctor\n";
    }

    // Copy assignment operator
    Resource& operator=(const Resource& other) {
        if (this != &other) {
            delete[] data;
            data = new int[100]; // May throw std::bad_alloc
            std::copy(other.data, other.data + 100, data);
        }
        std::cout << "Copy assign\n";
        return *this;
    }

    // Move constructor WITHOUT noexcept
    Resource(Resource&& other) {
        data = other.data;
        other.data = nullptr; // State after move may be undefined if throw
        std::cout << "Move ctor (no noexcept)\n";
        // Simulate possible exception (for demonstration)
        // if (true) throw std::runtime_error("Error during move!");
    }

    // Move assignment operator WITHOUT noexcept
    Resource& operator=(Resource&& other) {
        if (this != &other) {
            delete[] data;
            data = other.data;
            other.data = nullptr; // State after move may be undefined if throw
        }
        std::cout << "Move assign (no noexcept)\n";
        // Simulate possible exception
        // if (true) throw std::runtime_error("Error during move!");
        return *this;
    }

private:
    int* data;
};

class ResourceNoexcept {
public:
    ResourceNoexcept() { data = new int[100]; std::cout << "Noexcept Default ctor\n"; }
    ~ResourceNoexcept() { delete[] data; std::cout << "Noexcept Dtor\n"; }

    // Copy constructor
    ResourceNoexcept(const ResourceNoexcept& other) {
        data = new int[100];
        std::copy(other.data, other.data + 100, data);
        std::cout << "Noexcept Copy ctor\n";
    }

    // Copy assignment operator
    ResourceNoexcept& operator=(const ResourceNoexcept& other) {
        if (this != &other) {
            delete[] data;
            data = new int[100];
            std::copy(other.data, other.data + 100, data);
        }
        std::cout << "Noexcept Copy assign\n";
        return *this;
    }

    // Move constructor with noexcept
    ResourceNoexcept(ResourceNoexcept&& other) noexcept {
        data = other.data;
        other.data = nullptr; // Safe, as it does not throw
        std::cout << "Noexcept Move ctor (with noexcept)\n";
    }

    // Move assignment with noexcept
    ResourceNoexcept& operator=(ResourceNoexcept&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            other.data = nullptr; // Safe, as it does not throw
        }
        std::cout << "Noexcept Move assign (with noexcept)\n";
        return *this;
    }

private:
    int* data;
};

int main() {
    // Vector with Resource class (without noexcept on move)
    std::cout << "--- Vector with Resource (no noexcept) ---\n";
    std::vector<Resource> vec1;
    vec1.reserve(3); // Initial capacity
    vec1.emplace_back();
    vec1.emplace_back();
    // On resize, copying may occur because move is not guaranteed to be noexcept
    std::cout << "Resizing vec1...\n";
    vec1.resize(3); // If capacity < 3, reallocation occurs
    std::cout << "-----------------------------------------\n\n";

    // Vector with ResourceNoexcept class (with noexcept on move)
    std::cout << "--- Vector with ResourceNoexcept (with noexcept) ---\n";
    std::vector<ResourceNoexcept> vec2;
    vec2.reserve(3); // Initial capacity
    vec2.emplace_back();
    vec2.emplace_back();
    // On resize with noexcept move, elements will be moved
    std::cout << "Resizing vec2...\n";
    vec2.resize(3); // If capacity < 3, reallocation occurs
    std::cout << "--------------------------------------------\n";

    return 0;
}

In main, during vec1.resize(3), elements are copied because Resource does not guarantee that move will not throw. During vec2.resize(3), elements are moved because ResourceNoexcept is marked as noexcept, allowing the vector to safely use move semantics during reallocation.