C++ win32 thread createThread function not passing parameter correctly - c++

Question

So, I have been trying to figure out how c++ multi-threading works and how to apply it to the project I am working on. I am trying to accomplish creating a new thread and running a function on that thread. The function I am trying to run is called SetupInfo and takes an Individual as a single parameter. I have seen examples of this and have tried to implement them, but after multiple attempts I cannot successfully pass the parameter I need into the thread I want the function to run on. Here is what I have come up with:
Here I create a struct to store the pointer to the Individual that I need later on.
struct ThreadData
{
Individual *m_pInd;
ThreadData(Individual pInd) : m_pInd(*pInd) {}
};
Here I create a function that I can call in my program that creates the thread that runs the function SetupThreadFunction which takes a void pointer as a parameter. I am trying to pass the variable data into this function and then cast it back to ThreadData to be able to access the items of the struct.
void SetupThread(Individual input)
{
ThreadData *data = new ThreadData(input);
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SetupThreadFunction, data , 0, 0);
delete data;
}
Here I create the function that is passed into the CreateThread function which takes a void pointer and casts it to ThreadData which can then theoretically access the threadData->m_pInd. The same pointer for data above is passed correctly into the SetupThreadFunction. However, m_pInd contains null data and not the pointer to the information that is expected. Why is that?
DWORD WINAPI SetupThreadFunction(LPVOID lpParameter)
{
ThreadData* threadData = (ThreadData*)lpParameter;
SetupInfo(threadData->m_pInd);
return 0;
}
Is there a more correct way to pass a parameter into the new win32 thread I am creating?

Answer 1

The correct pattern is to allocate the object with new, fill in the data (if not done through parameters to new), pass the pointer to the newly-created thread, and let the thread delete the object when it's done with it. You delete the object before you know the thread has even started!

Answer 2

This isn't a multithreading problem; it's a pointer problem.
This line doesn't make sense to me:
ThreadData(Individual pInd) : m_pInd(*pInd) {}
m_pInd is a pointer and yet you're initializing it with *pInd which means you want to dereference pInd, but pInd is not a pointer, let alone a pointer to a pointer. I don't see how this would even compile.
Assuming you actually meant & instead of *, as in:
ThreadData(Individual ind) : m_pInd(&ind) {}
The problem here is that you're creating a pointer to a copy of an Individual on the stack, and that copy goes away upon return from the constructor, so you have a dangling pointer.

Answer 3

Use std::thread.
void ThreadProc(Individual individual);
int main()
{
Individual individual;
std::thread thread(ThreadProc, individual);
thread.join();
return 0;
}

Answer 4

Here's a simple code example to demonstrate the points already discussed.
#include "stdafx.h" // includes <windows.h>, <string> and <iostream>
using std::string;
using std::cout;
class Individual
{
public:
string s;
};
struct ThreadData
{
Individual *m_pInd;
ThreadData(Individual* pInd) : m_pInd(pInd) {}
};
DWORD WINAPI SetupThreadFunction(LPVOID lpParameter)
{
cout << "Hi From Thread\n";
ThreadData* threadData = static_cast<ThreadData*>(lpParameter);
//SetupInfo(threadData->m_pInd);
// do delete here, once its finished with.
delete threadData;
return 0;
}
HANDLE SetupThread(Individual* input)
{
ThreadData *data = new ThreadData(input);
return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SetupThreadFunction, data , 0, 0);
}
int _tmain(int argc, _TCHAR* argv[])
{
cout << "Hi\n";
Individual* i = new Individual;
HANDLE h = SetupThread(i);
if(h)
{
WaitForSingleObject(h, INFINITE);
cout << "Done\n";
} else
{
cout << "Couldnt create thread\n";
}
getchar();
delete i;
return 0;
}
Bear in mind also you can use _beginthread as a simpler interface to launch a thread on Win32.