类的成员函数做线程的创建

       类的成员函数 是不能作为线程的参数，去创建线程的。原因我个人认为是：我们创建的对象，在超出作用域的时候，会自动的销毁掉。这样的话线程这是可能还没有销毁，会引起问题。所以线程的静态函数，可以去作为线程的参数，因为其不会因为类的对象销毁而销毁。这个原理 其实和类的静态函数不能使用非静态的成员函数一样。原因就是其静态函数存在，如果函数体内用了成员变量，对象销毁了，函数会异常。

      如果我们要是类的成员函数去作为线程函数，怎么办呢。可以先用静态的函数去创建 一个线程，然后将一个类指针传入到这个指针。（注意类的对象不要在线程运行期间不要销毁）

#include<stdlib.h>
#include<process.h>
#include<iostream>
#include "windows.h"
using namespace  std;

class fobj
{
public:
  virtual	 bool find()
	{
		cout<<"find _f"<<endl;
		return false;
	}
  void  dynstartThread();
  static unsigned int  __stdcall BASICmemberThread(void *p)
  {
	  return dynamic_cast<fobj*>((fobj*)p)->memberFun(NULL);
  }
  int fb;
private:
	virtual 
		unsigned int memberFun(void* laparam);


};
unsigned int   fobj::memberFun(void* laparam)
{
	cout<<" Fobj 类 普通函数  basic"<<endl;
	return 0;
}
void  fobj::dynstartThread()
{
	UINT m_nThreadID;	
	HANDLE	m_hThread;
	cout<<"this add:"<<this<<endl;
	m_hThread = (HANDLE)_beginthreadex( NULL, 0, BASICmemberThread, this, 0, &m_nThreadID );

}
class  object:public fobj
{
public:
	int aobj;
	
	object()
	{
		cout<<"object gen****888"<<endl;
		pint=new int;
	}
	~object()
	{
		
		delete pint;
		cout<<"object decontror####"<<endl;
	}
	int *pint;
	void  startThread();
	//非static 函数不能作为线程函数实现
	static unsigned int  __stdcall memberThread(void *p);
  
protected:
	
private:
	//普通成员函数
//	virtual 
		unsigned int memberFun(void* laparam);

};
unsigned int object:: memberFun(void* laparam)
 {
	 cout<<" obj 类 普通函数 "<<endl;
	
	  aobj=8000;
	  Sleep(aobj);
	   aobj=1;
	   *pint=200;
	  cout<<" obj 子类 普通函数 "<<"aobj--"<<aobj<<"pint"<< *pint<<endl;

	 return 0;
 }
unsigned int  object::memberThread(void *p)
{
	//int a=aobj;
	Sleep(3000);
	cout<<"memberThread"<<endl;
	return 0;
}

void  object::startThread()
{
	 UINT m_nThreadID;	
	 HANDLE	m_hThread;
	   
	m_hThread = (HANDLE)_beginthreadex( NULL, 0, memberThread, this, 0, &m_nThreadID );

};

void main()
{
	//object aat;
	//aat.find();
	//通过类的成员函数启动类的静态函数作为线程
	//aat.startThread();

	UINT m_nThreadID;//线程ID
	HANDLE	m_hThread;
	//直接启动类的静态函数作为线程
	//m_hThread = (HANDLE)_beginthreadex( NULL, 0, aat.memberThread, &aat, 0, &m_nThreadID );

	//基类的指针去调用静态函数创建线程，线程的参数 转变成对象去调用成员函数。 实现了多态
	//必选要对成员函数加virtual  即使成员函数是私有的。
	//fobj* pf=new object;
	//pf->dynstartThread();
	cout<<"#######以下程序bbt是局部变量，释放了指针在赋值危险#######"<<endl;
	if(1)
	{
		object bbt;
	    fobj* robj=&bbt;
		cout<<"addrobj:"<<&bbt<<endl;
	    robj->dynstartThread();
		cout<<"即将出界了"<<endl;
	}
	cout<<"已经出界了"<<endl;
	int * pintnew= new int[10000];
	system("pause");
 
}

以上程序就可能会引起不确定的问题，因为对象销毁了，而线程并没有销毁。