Thread in class virtual member function - c++

Question

I want to make a threading object, the member function "run" can be overridden. When I add the word "virtual", it will fail. Can someone help me - how can i make a threading object. The object can be inherited and the member function can be overridden.
#include <iostream>
#include <process.h>
using namespace std;
class thread
{
private:
static void gangplank(void *ptr)
{
((thread *)ptr)->run();
}
public:
void start()
{
_beginthread(&this->gangplank,0,(void *)this);
//this->gangplank((void *)this);
}
virtual void run()
{
cout<<1;
}
~thread()
{
_endthread();
}
};
class d:public thread
{
public:
void run()
{
cout<<2;
}
};
int main()
{
d a;
a.start();
return 0;
}
The error message:
"text.exe Has stopped working - Windows is checking for a solution to the problem"
It didn't have compile error.

Answer 1

I don't know if this is your problem, since you just say that it
failed, without saying how, but you don't wait for the thread to
finish in main, so you may be destructing the thread object
before the thread starts to run.

Answer 2

Remove _endthread from destructor.
MSDN:
You can call _endthread or _endthreadex explicitly to terminate a
thread; however, _endthread or _endthreadex is called automatically
when the thread returns from the routine passed as a parameter to
_beginthread or _beginthreadex. Terminating a thread with a call to endthread or _endthreadex helps to ensure proper recovery of resources
allocated for the thread.
Ok, I got it now, _endthread in destructor it's not real problem here, you must wait for thread in the main function.
#include <process.h>
#include <iostream>
using namespace std;
class thread
{
private:
HANDLE m_handle;
static void gangplank(void *ptr)
{
((thread *)ptr)->run();
}
public:
HANDLE getHandle() const {return m_handle;}
void start()
{
m_handle = (HANDLE)_beginthread(&this->gangplank,0,(void *)this);
}
virtual void run()
{
cout<<1;
}
~thread()
{
//_endthread();
}
};
class d:public thread
{
public:
void run()
{
cout<<2;
}
};
int main()
{
d a;
a.start();
WaitForSingleObject(a.getHandle(), INFINITE);
return 0;
}

Answer 3

Use std::thread instead of the native C API. It uses function objects, so you probably won't even need virtual functions. If your compiler doesn't support C++11, then you can use boost::thread, which is almost the same (actually, it uses the native API directly).
Here is an example:
#include <thread>
#include <iostream>
void run()
{
std::cout << "run" << std::endl;
}
int main()
{
std::thread t(run);
t.join();
}
Or you can also call class members:
#include <thread>
#include <functional>
#include <iostream>
class A {
public:
void run()
{
std::cout << "run" << std::endl;
}
};
int main()
{
A a;
std::thread t(std::bind(&A::run, &a));
t.join();
}
It is generally advised to use higher-level API if possible instead of creating a wrapper to C library calls yourselves. APIs in the C++ standard (and usually in Boost too) are generally better implemented than an average programmer could do, and it surely saves a lot of time than making a good implementation yourself.