Segmentation fault because of moved promise - c++11

Question

I've passed a promise as a reference to a thread. Afterwards, the promise was moved into a vector via std::move. This is causing a segmentation fault when the software is executed.
I reckon the reference in the thread is never updated after moving the promise? How can I pass the promise to the thread so that I can move it afterwards? Please see the following code example of my problem.
#include <iostream>
#include <thread>
#include <vector>
#include <future>
class Test {
public:
std::thread t;
std::promise<int> p;
Test(std::thread&& rt, std::promise<int>&& rp) : t(std::move(rt)), p(std::move(rp)) {}
};
int main()
{
std::vector<Test> tests;
{
auto p = std::promise<int>();
std::thread t ([&p]{
std::cout << 1;
p.set_value(1);
});
tests.push_back(Test(std::move(t), std::move(p)));
}
for(Test& mytest : tests)
{
mytest.t.join();
}
}

Answer 1

The promise p that the lambda holds a reference to is moved from and goes out of scope. You'll need an extra level of indirection so that the promise never moves.
auto pp = std::make_unique<std::promise<int>>();
std::thread t ([p = pp.get()] { // <--- p is a promise<int>*
std::cout << 1;
p->set_value(1);
});
This way, the promise never moves, you just move the pointer. The lambda gets a regular non-owning pointer to the promise.
See it here.

Answer 2

I do not have an answer to your question. At least, I have none yet. However, no other answers seem to have appeared yet and I find your question is interesting, so let's try this:
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <memory>
class Test {
public:
std::thread t;
std::unique_ptr<std::promise<int>> pp;
Test(std::thread&& rt, std::unique_ptr<std::promise<int>>&& rpp)
: t(std::move(rt)), pp(std::move(rpp)) {}
};
int main()
{
std::vector<Test> tests;
{
auto pp = std::make_unique<std::promise<int>>();
std::thread t ([&pp]{
std::cout << 1;
pp->set_value(1);
});
tests.push_back(Test(std::move(t), std::move(pp)));
}
for(Test& mytest : tests)
{
mytest.t.join();
}
}
Do you see what I did there? I indirected ownership of the promise through a smart pointer. We know that smart pointers destruct gracefully, so the promise itself is never moved by this code, but only the pointer to the promise is moved. Yet the code still segfaults.
So are we sure that the promise is actually what is causing the segfault?
Maybe the promise is indeed causing the segfault, but now at least we have another way to attack the problem—unless you have already tried this.