cpp
#include <iostream>
#include <thread>
#include <chrono>

// A function that attempts to use a reference argument
void process_data_unsafe(int& data_ref) {
    // Simulate some work
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    std::cout << "Thread processing data (unsafe): " << data_ref << std::endl;
}

int main() {
    // --- DANGER ZONE: Dangling Reference Example ---
    std::cout << "--- Demonstrating Dangling Reference ---\n";
    
    // 'local_data' is a stack variable within main's scope
    int local_data = 100;

    // We launch a thread, passing 'local_data' by reference.
    // The thread 't1' might outlive main's scope where 'local_data' exists.
    std::thread t1(process_data_unsafe, std::ref(local_data));

    // main function exits quickly, 'local_data' is destroyed.
    // If the thread 't1' tries to access 'data_ref' after this point,
    // it will be accessing deallocated memory (undefined behavior).

    // In a real scenario, the main thread might continue, or immediately join/detach.
    // For demonstration, let's just let main finish and observe potential crash.
    // To make the UB more likely to manifest, we might detach or let it run without join.
    
    // We must join the thread to avoid program termination issues, but this doesn't fix the UB
    // if the thread's work happens after 'local_data' is out of scope.
    // In this specific example, the thread might print before main finishes, but the *potential* for UB exists.
    t1.join(); // Joining ensures t1 completes before main exits, but if main finishes and 'local_data' is gone,
               // and then t1 tries to access it, it's UB.

    std::cout << "Main thread finished. local_data is out of scope.\n";

    // --- Safe Passing by Value (Contrast) ---
    std::cout << "\n--- Demonstrating Safe Passing by Value (No UB) ---\n";
    int safe_data = 200;
    std::thread t2([](int data_val) {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        std::cout << "Thread processing data (safe by value): " << data_val << std::endl;
    }, safe_data); // 'safe_data' is copied into the thread's argument
    t2.join();
    std::cout << "Main thread finished. safe_data is out of scope.\n";

    return 0;
}

cpp
#include <iostream>
#include <thread>
#include <vector>
#include <string>
#include <utility> // For std::move
#include <future>  // For std::async

// Function that processes a vector by value (makes a copy)
void process_vector_by_value(std::vector<int> data) {
    std::cout << "Thread (by value): Processing vector of size " << data.size() << std::endl;
    if (!data.empty()) {
        data[0] = 999; // Modify local copy
    }
}

// Function that processes a vector by rvalue reference (moves ownership)
void process_vector_by_move(std::vector<int>&& data) {
    std::cout << "Thread (by move): Processing vector of size " << data.size() << std::endl;
    if (!data.empty()) {
        data[0] = 888; // Modify owned data
    }
    // 'data' will be destroyed when this function exits
}

// Function for std::async that takes an object by value
std::string greet_by_value(std::string name) {
    name += " (Processed)";
    return "Hello, " + name;
}

int main() {
    // --- Passing by Value with std::thread ---
    std::cout << "--- Passing by Value ---\n";
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    std::cout << "Original vec1[0]: " << vec1[0] << std::endl;
    std::thread t1(process_vector_by_value, vec1); // vec1 is copied
    t1.join();
    std::cout << "After t1, original vec1[0]: " << vec1[0] << " (should be 1 - no change)" << std::endl;

    // --- Passing by Move with std::thread ---
    std::cout << "\n--- Passing by Move ---\n";
    std::vector<int> vec2 = {10, 20, 30, 40, 50};
    std::cout << "Original vec2 size: " << vec2.size() << std::endl;
    // std::move transfers ownership. 'vec2' is now in a valid but unspecified state.
    std::thread t2(process_vector_by_move, std::move(vec2)); 
    t2.join();
    // Accessing vec2 here is safe but its content is likely empty/moved-from
    std::cout << "After t2, vec2 size: " << vec2.size() << " (should be 0 - moved-from)" << std::endl;

    // --- Passing with std::async (often performs moves implicitly for rvalues) ---
    std::cout << "\n--- Passing with std::async ---\n";
    std::string user_name = "Alice";
    std::cout << "Original user_name: " << user_name << std::endl;
    // std::async will likely move 'user_name' if it's an rvalue, or copy if an lvalue.
    // In this case, 'user_name' is an lvalue, so it's copied.
    std::future<std::string> future_result1 = std::async(std::launch::async, greet_by_value, user_name);
    std::cout << "After async call, original user_name: " << user_name << " (should be Alice - copied)" << std::endl;
    std::cout << "Async result (copy): " << future_result1.get() << std::endl;

    std::string another_name = "Bob";
    std::cout << "\nOriginal another_name: " << another_name << std::endl;
    // Explicitly moving for std::async
    std::future<std::string> future_result2 = std::async(std::launch::async, greet_by_value, std::move(another_name));
    std::cout << "After async call, another_name: " << another_name << " (should be empty/moved-from)" << std::endl;
    std::cout << "Async result (move): " << future_result2.get() << std::endl;

    return 0;
}

cpp
#include <iostream>
#include <thread>
#include <memory> // For std::shared_ptr
#include <string>
#include <vector>
#include <chrono>

// A custom data structure to demonstrate shared ownership
struct SharedResource {
    std::string name;
    std::vector<int> data;

    SharedResource(std::string n, std::vector<int> d) : name(std::move(n)), data(std::move(d)) {
        std::cout << "SharedResource '" << name << "' constructed.\n";
    }

    ~SharedResource() {
        std::cout << "SharedResource '" << name << "' destroyed.\n";
    }

    void print_data() const {
        std::cout << "Resource '" << name << "' data: ";
        for (int x : data) {
            std::cout << x << " ";
        }
        std::cout << "\n";
    }
};

// Function to process the shared resource using std::shared_ptr
void process_shared_resource(std::shared_ptr<SharedResource> resource_ptr) {
    std::cout << "Thread: Processing shared resource '" << resource_ptr->name << "'. Use count: " << resource_ptr.use_count() << "\n";
    resource_ptr->data[0] = 777; // Modify shared data
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    resource_ptr->print_data();
    std::cout << "Thread: Finished processing '" << resource_ptr->name << "'.\n";
    // resource_ptr goes out of scope, decrementing reference count
}

int main() {
    std::cout << "--- Engineering Robust Ownership with std::shared_ptr ---\n";

    // Create a shared_ptr to our resource
    auto my_resource = std::make_shared<SharedResource>("Global Data", std::vector<int>{1, 2, 3});
    std::cout << "Main: Initial use count: " << my_resource.use_count() << "\n"; // Should be 1

    // Launch multiple threads, each receiving a copy of the shared_ptr.
    // Each copy increments the reference count.
    std::thread t1(process_shared_resource, my_resource); // Pass by value, shared_ptr is copied
    std::thread t2(process_shared_resource, my_resource); // Pass by value, shared_ptr is copied again

    std::cout << "Main: Use count after launching threads: " << my_resource.use_count() << "\n"; // Should be 3 (main, t1, t2)
    
    // Simulate main thread doing other work
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    my_resource->data[1] = 666; // Main also modifies shared data

    t1.join();
    t2.join();

    std::cout << "Main: All threads joined. Final resource data: ";
    my_resource->print_data();
    std::cout << "Main: Final use count: " << my_resource.use_count() << "\n"; // Should be 1 (only main holds it)

    // --- Custom Callable Wrapper Example (Lambda by value capture) ---
    std::cout << "\n--- Custom Callable Wrapper (Lambda) ---\n";
    int value_to_capture = 42;
    std::string message_to_capture = "Hello from main";

    auto my_lambda = [value_to_capture, message_to_capture]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        std::cout << "Lambda Thread: Captured value = " << value_to_capture 
                  << ", Message = \"" << message_to_capture << "\"\n";
    }; // value_to_capture and message_to_capture are copied into the lambda object

    std::thread t3(my_lambda);
    t3.join();

    std::cout << "Main: Original value_to_capture: " << value_to_capture << "\n";
    std::cout << "Main: Original message_to_capture: " << message_to_capture << "\n";

    return 0;
} // my_resource is destroyed here, as use count becomes 0.

cpp
#include <iostream>
#include <thread>
#include <future>   // For std::packaged_task, std::promise, std::future
#include <string>
#include <vector>
#include <chrono>
#include <utility>

// A function to be executed asynchronously
int calculate_sum(std::vector<int> numbers) {
    std::cout << "Task Thread: Starting sum calculation for vector of size " << numbers.size() << "\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Simulate heavy work
    int sum = 0;
    for (int n : numbers) {
        sum += n;
    }
    std::cout << "Task Thread: Calculation complete. Sum = " << sum << "\n";
    return sum;
}

// A function that sets a promise result
void fulfill_promise(std::promise<std::string> prom, const std::string& message) {
    std::cout << "Promise Thread: Fulfilling promise with message: \"" << message << "\"\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    prom.set_value(message + " (processed)");
    std::cout << "Promise Thread: Promise fulfilled.\n";
}

int main() {
    std::cout << "--- Optimizing Asynchronous Flow with std::packaged_task ---\n";

    // Create a vector of numbers to pass to the task
    std::vector<int> my_numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // Create a packaged_task. It stores the callable and manages its arguments.
    // Note: The vector `my_numbers` is copied into the packaged_task.
    std::packaged_task<int(std::vector<int>)> task(calculate_sum);

    // Get a future associated with the task. This future will hold the result.
    std::future<int> task_future = task.get_future();

    // Launch a thread to execute the packaged_task. std::move(task) transfers ownership.
    std::thread task_thread(std::move(task), my_numbers); 
    // The original my_numbers is copied into the packaged_task upon its construction.
    // Then, the packaged_task object itself is moved into the thread.
    // The arguments for the *callable* (calculate_sum) are passed when the *packaged_task* is called/run.
    // If we passed `std::move(my_numbers)` to the thread here, it would be incorrect for `calculate_sum`'s signature
    // which expects a `std::vector<int>`. The arguments for `calculate_sum` are implicitly bound at task construction 
    // or when the task is run. When launching a thread for a packaged_task, you pass the task itself, and then its arguments.
    // Here, `std::thread(std::move(task), my_numbers)` means `task` is moved to the thread, and `my_numbers` is passed as argument to `task`'s operator().
    // To be clear, `calculate_sum` will receive a *copy* of `my_numbers` from the `packaged_task`'s internal state.

    std::cout << "Main Thread: Task launched. Waiting for result...\n";
    // Do other work while the task is executing...
    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    // Retrieve the result from the future. This call blocks until the result is available.
    int result = task_future.get();
    std::cout << "Main Thread: Task result: " << result << "\n";

    task_thread.join(); // Join the task thread

    std::cout << "\n--- Communicating with std::promise and std::future ---\n";

    // Create a promise object
    std::promise<std::string> my_promise;
    // Get a future from the promise
    std::future<std::string> promise_future = my_promise.get_future();

    // Launch a thread, moving the promise into it. The thread will fulfill the promise.
    std::thread promise_thread(fulfill_promise, std::move(my_promise), "Data from main");

    std::cout << "Main Thread: Promise thread launched. Waiting for promise fulfillment...\n";

    // Do other work...
    std::this_thread::sleep_for(std::chrono::milliseconds(30));

    // Get the value from the future. This blocks until the promise is set.
    std::string promise_result = promise_future.get();
    std::cout << "Main Thread: Received from promise: \"" << promise_result << "\"\n";

    promise_thread.join(); // Join the promise thread

    return 0;
}