220404_default_move_operator_fails.cpp

// This sample code demonstrates a case where default generated move operator is dangerous
// Based on Nicolai Josuttis' "C++ Move Semantics"
// Chapter on "Non-Destructible Moved-From Objects"
// Chapter on "Move Semantics for Containers"

#include <array>
#include <vector>
#include <thread>
#include <chrono>
#include <iostream>

// class that holds an std::array of 10 std::thread's
class Task_array {
public:
    // moves a thread to the std::array
    template <typename T>
    void launch(T op) { threads[num_threads++] = std::thread(std::move(op)); }

    // wait for each thread to end
    ~Task_array() {
        std::cout << num_threads << std::endl;
        for (int i = 0; i < num_threads; ++i)
            threads[i].join();
    }

    Task_array() = default;
    Task_array(Task_array&&) = default;

private:
    std::array<std::thread, 10> threads;
    int num_threads{0};
};

// class that holds a std::vector of std::thread's
class Task_vector {
public:
    // adds a thread to the std::vector
    template <typename T>
    void launch(T op) { threads.push_back(std::thread(std::move(op))); }
    
    // wait for each thread to end
    ~Task_vector() {
        std::cout << threads.size() << std::endl;
        for (auto& t : threads)
            t.join();
    }

    Task_vector() = default;
    Task_vector(Task_vector&&) = default;

private:
    std::vector<std::thread> threads;
};

int main()
{
    try {
        using namespace std::chrono_literals;
 
        Task_array ta;
        ta.launch([]{ std::this_thread::sleep_for(1s); std::cout << "array:first thread" << std::endl; });
        ta.launch([]{ std::this_thread::sleep_for(1.5s); std::cout << "array:second thread" << std::endl; });

        // Q1: What happens if we uncomment this line? (Hint: What happens when 'ta' is destructed?)
        //Task_array ta_ = std::move(ta);

        Task_vector tv;
        tv.launch([]{ std::this_thread::sleep_for(2s); std::cout << "vector:first thread" << std::endl; });
        tv.launch([]{ std::this_thread::sleep_for(2.5s); std::cout << "vector:second thread" << std::endl; });

        // Q2: Why is it okay with vector?
        Task_vector tv_ = std::move(tv);

        // Q3: At the end of this code block, local objects are destroyed in the reverse order.
        //     The destructors of Task_array and Task_vector print something to stdout.
        //     What will be their output?
    } catch (std::exception& e) {
        std::cout << "exception catched: " << e.what() << std::endl;
    }
}

// A1. By the defaulted move constructor, num_threads is copied while each element of the array is moved.
//     The moved-from object 'ta' has num_threads equal to 2 but every element of the array is unjoinable
//     because they are moved-from. (This is one of the four unjoinable condintions. See "Effective Modern
//     C++", item 37.) At the end of the code block, the destructor for the moved-from object 'ta' calls
//     join on unjoinable std::thread object. Therefore, program is terminated.

// A2. Unlike the move constructor for std::array where each element is moved, the move constructor for std::vector
//     moves the address to the heap where actual data is stored. (std::array stores elements on the stack
//     while std::vector stores elements on the heap.) Therefore, the moved-from object 'tv' does not contain
//     any threads.

// A3. Destructor of tv_ : 2
//     Destructor of tv : 0
//     Destructor of ta_(if uncommented) : 2
//     Destructor of ta : 2