As an example in pseudocode:

MultiThreadedWorker worker;

Foo()
{
    const Vector position = CreatePosition();
    
    worker.StartWorker(Position);
}

MultiThreadedWorker::StartWorker(const Vector& myPosition)
{
    ... Do a bunch of async work that keeps referencing myPosition ...
}

This seems to be working for now, but I don't understand why because it seems that myPosition would end up pointing to nothing long before StartWorker completed.

Assuming this isn't safe, is there any solution other than just passing around everything by value or ensuring it's all on the heap?

CodePudding user response：

std::async copies const references

So yes, it is safe. For a discussion of why it does, see Why does std::async copy its const & arguments?

CodePudding user response：

It is programmers responsibility to ensure that variable live long enough so that it is not destroyed before any access through pointers or references. This can be achieved through at least by one of the following:

1. Ensure the thread ends before destroying the variable. You can run .join() on the thread before leaving the scope.

2. Create object on the heap. Create it using make_shared and pass shared_ptr. This ensures the object lives until the last reference is destroyed.

Note that there is another problem with threads and shared objects. If one thread writes when another thread reads to the same object, then it is a data race which is Undefined Behavior. Thread synchronization mechanisms such as std::mutex can be used to avoid this.