C / C++ / MFC

BTW In fact there is a direct solution of your problem, and it is so ugly that I cannot resist the temptation to post it :

[modified afterwards Cedric Moonen reply  :-O ].
//-> HERE STARTS BAD CODE
class className;
struct MyUglyThreadArg
{
 className * pClass;
 int * px;
};
class className
{

  ...
  MyUglyThreadArg muta;
  void methodName()
  {
    static int x = 100;
    muta.pClass = this;
    muta.px = &x;
    _beginthread(&threadFunction, 0, &muta);
  }
...
}; 

void threadFunction( void *p )
{
  if ( ! p ) return;
  MyUglyThreadArg *pMuta = (MyUglyThreadArg *) p;
  className * pClass = (className *) p->pClass; 
  pClass->m_count++; // where count is class public int data
  *(pMuta->px) = 200; 
...
}
//<- HERE ENDS BAD CODE

Cedric Moonen wrote:

A better way to deal with it in OOP is to start the thread from within a class and pass the this pointer to the thread function. Then in your function, you can cast it back to a class pointer and call some public method of your class.

CPallini wrote:

is hazardous too: the bug coming out if the class instance goes out-of-scope while thread function is running.

Cedric Moonen wrote:

That's not very usefull: it is kind of a snake that bites its own tail. You pass in a structure which contains a pointer to the class which itself contains the structure. So, what's the point ? So, you still can't pass different 'x' values to different threads (here again, potential race condition). Because I suppose if the OP wanted to do something like that was because he plans to start several threads and pass some specific information to each of them along the this pointer.

Cedric Moonen wrote:

Because I suppose if the OP wanted to do something like that was because he plans to start several threads and pass some specific information to each of them along the this pointer

Cedric Moonen wrote:

There is a workaround that but which is ugly too: create the structure on the heap and delete it inside the thread function.

CPallini wrote:

The above scenario breaks your code too (unless he starts a single thread per class instance).

class gladiator
{
	gladiator() {}
	virtual ~gladiator()
	{
		// moriuntur te salute
		_beginthread(&threadFunction, 0, this);
	}

	static void threadFunction(void *pargList)
	{
		if (!pargList)
			return;

		gladiator * pActor = static_cast<gladiator *>(pargList);
		
		// pActor dead or about to be; using it will be deadly.

		_endthread();
	}
};

class gladiator
{
	gladiator()
	:	m_bThreadAlive(false),
		m_bStopThread(false),
		m_hThread(-1)
	{
		m_hThread = _beginthread(&threadFunction, 0, this);
		// check for error return value (-1)
	}
	virtual ~gladiator()
	{
		shutdown();
	}

protected:
	bool m_bThreadAlive; 
	bool m_bStopThread; 
	HANDLE m_hThread;

	virtual void shutdown()
	{
		if (m_bThreadAlive) {
			do {
				m_bStopThread = true;
			} while (m_bThreadAlive);
		}
	}

	static void threadFunction(void *pargList)
	{
		if (!pargList)
			return;

		gladiator * pActor = static_cast<gladiator *>(pargList);
		pActor->m_bThreadAlive = true;
		
		while (!pActor->m_bStopThread) {
			// fight
		}

		pActor->m_bThreadAlive = false;
		_endthread();
	}
}; 

void shutdown()
{
	if (m_bThreadAlive) {
		m_bStopThread = true;
		long lCoundown = 10000L;
		do {
			if (--lCoundown < 1L) {
				if (!TerminateThread(m_hThread, -1)) {
					// throw an exception
				}
				m_bThreadAlive = false;
			}
		} while (m_bThreadAlive);
	}
}

Lord_Draconis wrote:

It seems to work on XP but not on Vista but I maybe wrong.