Wahrscheinlich versuchst du aber als Threadfunktion eine Memberfunktion aus deiner Klasse aufzurufen.
Das geht aber nicht. WINAPI steht für die _stdcall Konventions, ruft man aber eine Memberfunktion auf, dann muss die _thiscall sein. Außderdem wird beim Aufruf einer Memberfunktion ja auch noch versteckt der this Zeiger als Parameter übergeben.

Deine Threadfunktion sollte also am einfachsten global sein.

gz

Wie kann ich dieses Problem lösen oder sind Threadfunktionen in Klassen nicht möglich???

Möglich schon, nur, wie pZy schon sagte, keine Member-Funktionen. Du musst schon eine static Funktion dafür nehmen. Es gibt aber trotzdem eine recht einfache Möglichkeit für das, was du vorhast. Dazu übergibst du einfach this als Thread-Funktionsparameter.

// Thread Erstellung - this_ ist die entsprechende Klasseninstanz, der du den Thread zuordnen willst
CreateThread(NULL, 0, &foo::my_static_main, this_, 0, NULL);
// deine Klasse
class foo
{
public:
	static DWORD WINAPI my_static_main(void* parameter)
	{
		foo* this_ = static_cast<foo*>(parameter);
		this_->my_main();
	}
	void my_main()
	{
		// das ist deine eigentliche Thread-Funktion - nun als Member
	}
};

Ich hab mir also nen Thread zum Senden von Zeichen über die RS232 geschaffen und zwar so wie von mir oben beschrieben.
Compiliert, keine Fehler.

Dann hab ich einen weiteren Thread hinzugefügt zum Empfangen von Zeichen über die RS232, da hab ich dann auf einmal auch Fehlermeldungen.

Ich werd dem Problem nochmal genauer auf den Pelz rücken und dann meine Erkenntnisse kundtun.

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

class X
{
  protected: 
    DWORD WINAPI Threadxyz (LPVOID lpParam)
    {
    }
  public:    
    void Threadaufrufer()
    {
      HANDLE hThread;
      DWORD dwParam, dwThreadID;
      hThread = CreateThread (NULL, 0, Threadxyz, &dwParam, 0, &dwThreadID);
    }
};

int _tmain()
{
  X x;
  x.Threadaufrufer();
}

Was sich definitiv nicht übersetzen lässt!

Da kann ich dir nur teilweise zustimmen, dass mein Code nicht funzt.

Es geht nicht darum, ob du mir zustimmst oder nicht. Dein Code ist falsch. Punkt. Und wenn dein Compiler das übersetzt, dann ist er diesbezgl. kaputt.
Und wenn du das noch immer nicht akzeptierst, dann beantworte mir doch mal folgende Frage:
Wie du sicherlich weisst, liegt jeder Member-Funktion (in deinem Fall X::Threadxyz) ein Objekt zu Grunde. Dieses lässt sich in der Funktion über this ansprechen und wird ausserhalb beim Aufruf explizit angegeben. Da CreateThread genau das macht, dh X::Threadxyz irgendwann aufruft, muss es also ein Objekt geben. Ich sehe in deinem CreateThread Aufruf allerdings keines. Du etwa? Und &X::Threadxyz, wie es übrigens korrekterweise heissen muss, ist nur ein Funktionszeiger. Mit Objekt is hier nix.

Wichtig dabei:

static nur in der Deklaration angeben,
der Thread kann nun nicht mehr auf Elementfunktionen und Membervariablen der eigenen Klasse zugreifen.

Ich hab meinen Threads dann ein Array von Pointern auf meine Membervariablen mitgegeben.
So ließ es sich dann fehlerfrei compilieren.

class ThreadObject{
  public:
    ThreadObject(int _id, HWND _hParent) { id = _id; hParent = _hParent;};
    void startWatch(void)
    {
        _beginthread(appWatch,0,(void *)this);
    }

  private:
    int id;
    HWND hParent;

    static void appWatch(void *tObject)
    {
      ThreadObject *obj = static_cast<ThreadObject*>(tObject);

      for(;;){
        Sleep(500 + (rand() % 5) * 100);
        SendMessage(obj->hParent,WM_THREAD_OBJECT_NOTIFY,(WPARAM)obj->id,NULL);
      }
    }
};

Sorry wegen der Klassen, ist aber in eine normale WinAPI Anwendung eingebettet.

Man holt sich mit

ThreadObject *obj = new ThreadObject(1001,hwnd);
obj->startWatch();

(Sorry wegen new )

ein ThreadObject und startet mit startWatch() den Thread dieses Objekts. Der Thread eines jeden Objekts schickt nun in relativ zufälligen Abständen eine Nachricht mit seiner id an das Hauptfenster, welches diese recht simpel ausgibt.

Dabei ist beim Benutzen von mehr als einem Objekt zu beobachten, dass die Nachrichten der Objekte immer stoßweise ankommen. Also zb so:

Nachricht id 1; 
Nachricht id 2; 
Nachricht id 3;

[600 millisec vergehen]

Nachricht id 1;
Nachricht id 2;
Nachricht id 3;

[1000 millisec vergehen]

Nachricht id 1;
Nachricht id 2;
Nachricht id 3;

[1100 millisec vergehen]

Nachricht id 1;
Nachricht id 2;
Nachricht id 3;

Die Abstände sind zufällig, jedoch sind sie bei allen Objekten gleich. Liegt das vielleicht sogar daran, dass der Zufallsgenerator bei paralellen Aufrufen die gleiche Zahl ausspuckt? Kann ich mir nicht vorstellen.

static void appWatch(void *tObject)
    {
      ThreadObject *obj = static_cast<ThreadObject*>(tObject);

      srand( (unsigned)time( NULL ) );

      for(;;){
        Sleep(500 + (rand() % 5) * 100);
        SendMessage(obj->hParent,WM_THREAD_OBJECT_NOTIFY,(WPARAM)obj->id,NULL);
      }
    }

Ich habe das Initialisieren jetzt mal in jedem Thread vorgenommen. Das bringt auch noch nix. Fügt man jedoch wie du sagtest einen Counter, der pro Initialisierung um sagen wir 100 erhhöt wird, zu time hinzu wird das gewünschte Ergebnis erzielt.

Interessante Sache, vielen Dank für die Tipps...

~nirsaja

Du musst den random in *jedem* Thread initialisieren!

Nein, eigentlich nicht. Es reicht einmal beim Programmaufruf.
Oder irr ich mich? Bin mir nicht 100% sicher.

mfg.

Jochen Kalmbach schrieb:

Du musst den random in *jedem* Thread initialisieren!

Nein, eigentlich nicht. Es reicht einmal beim Programmaufruf.
Oder irr ich mich? Bin mir nicht 100% sicher.

Du irrst Dich (debugge doch einfach mal in srand rein, dann siehst Du es)