Vector of thread pointers, push_back causes crash - c++

Question

I am new to C++, and I was lately looking into concurrency.
I tried to run this simple program demonstrating threads:
#include <vector>
#include <thread>
#include <stdio.h>
void threadWork()
{
printf("WORKER THREAD EXECUTING");
}
int main()
{
printf("INSTANTIATE THREAD\n");
std::vector<std::thread *> threadList;
threadList.push_back(&std::thread(&threadWork));
printf("THREAD INSTANTIATED JOINING...\n");
for (std::thread* t : threadList)
{
t->join();
}
printf("THREADS JOINED\n");
return 0;
}
After the call to push_back() the program crashes with a call to abort() (I am running this on Windows)
Why is this code crashing at runtime?

Answer 1

std::vector<std::thread *> threadList;
threadList.push_back(&std::thread(&threadWork));
Here you take the address of a temporary.
This is not permitted in C++, but Visual Studio lets you do it anyway.
That's a shame because the temporary is destroyed at the end of the call, so your vector contains nothing but a dangling pointer.
Furthermore, since you are not join()ing or detach()ing the thread, destroying its std::thread (which happens when it goes out of scope) causes your program to std::terminate() (commonly considered a crash).
I recommend re-reading the chapter in your C++ book about thread management, so that you can be assured of effecting it in a safe manner.
Forget about pointers here; you don't need them. Instead, just have a nice simple vector of threads, and directly construct your elements using emplace_back, like this:
std::vector<std::thread> threadList;
threadList.emplace_back(&threadWork);
Then ensure you join() your threads before program completion.

Answer 2

The program aborts because std thread aborts if you destroy it when it is running or finished.
This happens because you are storing a vector of pointers and taking the address of temporary objects. The first is a bad idea, the second is illegal in C++ but MSVC permits it by default.
In C++ you should default to using values, especially with std library types. And when you don't use values, use smart pointers. Using raw pointer should usually be either only for some function args, sometimes in a struct/class with reference semantics, or when doing C interop.
So here,
std::vector<std::thread> threadList;
is a vector of threads. No pointless pointers.
threadList.emplace_back(&threadWork);
that creates a new thread running threadwork/
for(auto& thread:threadList){
thread.join();
}
that joins the threads; this will wait until the thread is done. Failure to do something like this will make your program abort.
All together:
printf("INSTANTIATE THREAD\n");
std::vector<std::thread> threadList;
threadList.emplace_back(&threadWork);
printf("THREAD INSTANTIATED\n");
for(auto& thread:threadList){
thread.join();
}