Wie zum übergeben von Parametern an ein Thread-Objekt?

Ich bin mir nicht sicher, über C++, aber das ist, wie Sie es tun würde, in Java. Sie haben eine Klasse, die Sie erweitert-Thread (oder implementiert Runnable) und einen Konstruktor mit den Parametern, die Sie gerne weitergeben. Dann, wenn Sie beim erstellen des neuen Threads, die Sie zu Durchlaufen haben, in den Argumenten, und starten Sie dann den Faden, so etwas wie dieses:

Thread t = new MyThread(args...);
t.start();

Muss gleich sein in deinem Fall.

Hier ist ein typisches Muster:

1) Definieren Sie eine Datenstruktur, die kapselt alle Daten, die der thread braucht
2) In der main-thread instanziieren Sie eine Kopie der Datenstruktur auf dem heap, der operator new.
3) Füllen Sie die Daten-Struktur, werfen die Zeiger auf void* übergeben Sie die leere* auf die thread-Prozedur durch, was bedeutet, Sie werden durch eine thread-Bibliothek.
4) Wenn der worker-thread ruft die void*, es reinterpret_cast ist es an die Daten-Struktur, und dann übernimmt den Besitz des Objekts. Also wenn der thread fertig ist mit den Daten, die thread es freigibt, im Gegensatz zu den Haupt-thread freigeben es.

Hier ist Beispiel-code, den Sie kompilieren können & testen Sie in Windows.

    #include "stdafx.h"
    #include <windows.h>
    #include <process.h>

    struct ThreadData
    {
        HANDLE isRunning_;
    };

    DWORD WINAPI threadProc(void* v)
    {

    ThreadData* data = reinterpret_cast<ThreadData*>(v);
    if( !data )
        return 0;

    //tell the main thread that we are up & running
    SetEvent(data->isRunning_);

    //do your work here...

    return 1;
}

int main()
{
    //must use heap-based allocation here so that we can transfer ownership
    //of this ThreadData object to the worker thread.  In other words, 
    //the threadProc() function will own & deallocate this resource when it's
    //done with it.
    ThreadData * data = new ThreadData;
    data->isRunning_ = CreateEvent(0, 1, 0, 0);

    //kick off the new thread, passing the thread data
    DWORD id = 0;
    HANDLE thread = CreateThread(0, 0, threadProc, reinterpret_cast<void*>(data), 0, &id);

    //wait for the worker thread to get up & running
    //
    //in real code, you need to check the return value from WFSO and handle it acordingly.  
    //Here I assume the retval is WAIT_OBJECT_0, indicating that the data->isRunning_ event 
    //has become signaled
    WaitForSingleObject(data->isRunning_,INFINITE); 

    //we're done, wait for the thread to die
    WaitForSingleObject(thread, INFINITE);
    CloseHandle(thread);

    return 0;

}

Können Sie die übergabe der Parameter als member der thread-Klasse. Der thread wird erstellt, der thread kann vermutlich andere Methoden aufrufen, und/oder call-member-Funktionen bevor der thread gestartet wird. Daher kann es Auffüllen, was auch immer die Mitglieder sind notwendig, damit es funktioniert. Dann, wenn die run-Methode aufgerufen wird, wird es die notwendigen Informationen, um zu starten.

Gehe ich davon aus, dass Sie ein eigenes Objekt für jeden thread.

Würden Sie normalerweise alle threads, die Sie erstellen in ein array, vector etc.

Gut, ich würde es vorziehen, setzen Sie die Parameter in der Start() Methode, so können Sie ein protected-Konstruktor, und nicht die Kaskade die Parameter durch abgeleitete Klasse den Konstruktor.

Ich würde prolly lassen, meine Unabhängigkeitserklärung in etwa so Aussehen:

class Thread
{
public:
   virtual void Start(int parameterCount, void *pars);
protected:
   Thread();
   virtual void run(int parameterCount, void *pars) = 0;
}

Nur stellen Sie sicher, dass Ihre Parameter werden irgendwie vergeben, z.B. #1 int #2 wird ein doppelter etc. etc. 🙂