Ich möchte eine bestimmte Funktion in einem extra Thread ausführen lassen.
Diese Funktion ist in einer Klasse.
Siehe Code:

ULONG ThreadID;
				DWORD exitcode;
				HANDLE hThread_main=NULL;

				CCommunication com;
				com.M_SetComm(KSTP0,socket_j,0,pECB2);

				hThread_main=_beginthreadex(NULL,0,com.M_CommStr,&kostenstelle_str,0,&ThreadID);

Fehlermeldung:

Fehler 1 error C3867: "CCommunication::M_CommStr": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&CCommunication::M_CommStr", um einen Zeiger auf den Member zu erstellen

Mache ich den Aufruf so:

hThread_main=_beginthreadex(NULL,0,com.M_CommStr(&kostenstelle_str),&kostenstelle_str,0,&ThreadID);

Kommt folgende FEhlermeldung:

Fehler 1 error C2664: '_beginthreadex': Konvertierung des Parameters 3 von 'int' in 'unsigned int (__stdcall *)(void *)' nicht möglich

Nehme ich eine Funktion, die nicht in einer Klasse ist, funktioniert alles.

1. Ich verstehe nicht, daß er motzt,daß die Argumentliste fehlt, da das Argument der Funktion doch im nächsten Argument der Funktion _beginthreadex übergben wird.

2. Was kann der da nicht umwandeln?

Die Funktion com.M_CommStr gibt einen int zurück.

Kann mir jemand sagen was ich da falsch mache und warum es mit einen "normalen" funktion funktioniert?
Brauch der irgendwie die adresse der Klasse oder sowas?

Danke Mondmann

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

_beginthread benötigt keinen "statischen" Zeiger auf eine Funktion. Es ist kein Zeiger auf eine Methode erlaubt.

Also kann ich generell keine Methode einer Klasse als Threadfunktion angeben?
Static ist nicht drin, sollte Threadsicher sein...

Wäre eine mögliche Lösung, daß ich eine "normale" Funktion als Threadfunc nehme und in dieser eine Instanz der Klasse erzeuge und die Methode aufrufe?

Ich habs getestet, es funktioniert, nur ist die Frage obs Zufall ist oder richtig funktioniert...

Das "vielleicht" Problem dabei ist, daß ich bisher der Threadfunktion einen Zeiger auf einen string übergeben habe.
Diesen übergebe ich nun der neuen threadfunc und die threadfunc dann der Methode.

Die KLasse in der die Methode ist, ist in einer *.lib die ich gemacht habe...

Die Preisfrage ist eigentlich: Ist das Ganze dann noch Threadsicher?
Wie stehts mit der Lebensdauer der Variablen?

Hier mal etwas Code:

Erst die Klasse:

class CCommunication{

public:
	void M_SetComm();
	void M_CommStr(void);	

	CCommunication(void);	
	~CCommunication(void);	

	std::string empfang;	
	unsigned short Flag;
	unsigned int buffsize;
	std::string DebugLevel;
	SOCKET sock;
	EXTENSION_CONTROL_BLOCK *c_ECB;

	void CCommunikation(void)
	{
		this->empfang="";
		this->Flag=0;
		this->buffsize=0;
		this->DebugLevel="";
		this->sock=0,
		this->c_ECB=NULL;
	}

};

Die Threadfunktion:

void FKT_test(std::string &back)
{
	int ausw_pos;
	char ausweis[64];

	[b]CCommunication cm;[/b]
	CErrortext ce;
	cm.empfang = back;//Erst zuweisen, dann Ausweis extrahieren

	(.......)

			cm.sock = socket;
			cm.buffsize = MAX_REC_BUF;
			cm.DebugLevel = DEBUGLEVEL;						

		(.......)

		if(cm.sock == 0)
			throw( ce.M_error("002312",_zeile) );

               cm.M_CommStr();
	         back = cm.empfang;

// cm.empfang wird in M-ComStr() verarbeitet und neu beschrieben, diesen 
String brauche ich hier für die weitere verarbeitung.

}

Und die Methode:

void  CCommunication::M_CommStr()
{

// hier benutze ich alle Klassenvariablen.
// empfang vor allem wird beschrieben mit einem langen String.

empfang= "texttexttexttext............";

}

Der Aufruf:

com_plan=ausweis;
				com_plan+="/";
				com_plan+="PT_TAPL";//Grunddaten

hThread_main= chBEGINNTHREADEX(NULL,0,&[b]FKT_test[/b],(void*)&com_plan,0,&ThreadID);				

	DWORD dw=WaitForSingleObject(hThread_main,TIMETOWAIT);

				switch(dw)
				{
				case WAIT_OBJECT_0:
                                if(com_plan.empty());.......
                               Hier verarbeite ich com_plan weiter
                                break;
                                }

(....)
USW USF...

Ich warte also bis sich der Thread selbst beendet, wenn nicht dann wird er nach einer bestimmten Zeit beenden.

Sollte doch so funktionieren oder?
Die Variablen sollten mir bis zum zerstören des Threads zur Verfügung stehen.

Was meint Ihr?