Comment passer des paramètres à un objet Thread?

Je ne suis pas sûr que le C++, mais c'est la façon dont vous le feriez en Java. Vous auriez une classe qui étend la classe Thread (ou implements Runnable) et un constructeur avec paramètres que vous souhaitez passer. Ensuite, lorsque vous créez le nouveau thread, vous devez passer dans les arguments, et puis commencer le fil, quelque chose comme ceci:

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

Doit être le même dans votre cas.

Ici est un modèle typique:

1) Définir une structure de données qui encapsule toutes les données de votre fil besoins
2) Dans le thread principal, instancier une copie de la structure de données sur le tas à l'aide de l'opérateur new.
3) Remplir la structure des données, la fonte le pointeur de type void*, passer le void* pour la procédure de thread par tous les moyens qui vous sont fournis par votre bibliothèque de threads.
4) Lorsque le thread obtient le void*, il reinterpret_cast est-il de la structure de données, et prend alors possession de l'objet. Sens quand le fil est fait de ces données, le thread libère, en comparaison avec le thread principal de la désallocation il.

Voici un exemple de code, vous pouvez compiler & test de 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;

}

Vous pouvez passer les paramètres en tant que membres de la classe thread. Le fil qui crée le thread peut sans doute appeler d'autres méthodes et/ou d'appeler des fonctions de membre avant la discussion commence. Par conséquent, il est possible de remplir ce que les membres sont nécessaires pour que cela fonctionne. Puis, lorsque la méthode est appelée, elle aura toutes les informations nécessaires pour le démarrage.

Je suis en supposant que vous utilisez un objet distinct pour chaque thread.

Vous auriez normalement mettre tous les fils que vous créez dans un tableau, vecteur, etc.

Bien, je préfère mettre les paramètres dans la méthode Start (), de sorte que vous pouvez avoir protégé constructeur, et n'ont pas à mettre en cascade les paramètres par le biais de constructeur de classe dérivée.

Je serais pro que mon decleration ressembler à quelque chose comme ceci:

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

Assurez-vous que vos paramètres sont en quelque sorte contracté, par exemple #1 sera de type int, n ° 2 sera un double etc. etc. 🙂