Utilisation de Thread dans une classe

D'après Nicolas ROBERT:

J'ai créé un objet, et je veux qu'une de ses méthodes s'éxécute dans un
processus séparé. Mon code ressemble à ceci:

class MaClasse{

private:
HANDLE Htache;
DWORD IdTache;

public:
MaClasse();
~MaClasse();
int DemarreTache();
DWORD WINAPI ExecuteTache(LPVOID param);

};//fin de MaClasse

Ma question est la suivante, est-ce possible de creer une méthode du type
ExecuteTache ?

Oui, et non.

D'une part, pour pouvoir définir la fonction CreateThread et ses paramètres,
la fonction membre doit être statique.
Ce qui fait qu'elle ne peut plus accéder à ses objets, pour y remédier, on
lui passe en paramèter l'objet appelant (this).

De mémoire,
-je n'ai ni doc, ni exemple sous les yeux-
cela doit ressembler à ceci:

/* Declaration de la fonction membre */
static DWORD WINAPI ExecuteTache(LPVOID param);


Avec un appel sur
DWORD WINAPI MaClasse::ExecuteTache(LPVOID param){
MaClasse *Moimeme = (MaClasse*)param;
}

Avec this passé en paramètre dans le CreateThread.

Pour éviter de se taper tout plein de «MaClasse->», vous pouvez tout
simplement réduire ExecuteThread à l'appel d'une autre fonction membre:
dans .

DWORD WINAPI MaClasse::ExecuteTache(LPVOID param){
MaClasse *Moimeme = (MaClasse*)param;
return MoiMeme->FonctionThread();
}

>
> J'ai créé un objet, et je veux qu'une de ses méthodes s'éxécute dans un
> processus séparé. Mon code ressemble à ceci:

> class MaClasse{
>
> private:
> HANDLE Htache;
> DWORD IdTache;
>
> public:
> MaClasse();
> ~MaClasse();
> int DemarreTache();
> DWORD WINAPI ExecuteTache(LPVOID param);
>
> };//fin de MaClasse

> Ma question est la suivante, est-ce possible de creer une méthode du

type

> ExecuteTache ?

Oui, et non.

D'une part, pour pouvoir définir la fonction CreateThread et ses

paramètres,

la fonction membre doit être statique.
Ce qui fait qu'elle ne peut plus accéder à ses objets, pour y remédier, on
lui passe en paramèter l'objet appelant (this).

De mémoire,
-je n'ai ni doc, ni exemple sous les yeux-
cela doit ressembler à ceci:

/* Declaration de la fonction membre */
static DWORD WINAPI ExecuteTache(LPVOID param);


Avec un appel sur
DWORD WINAPI MaClasse::ExecuteTache(LPVOID param){
MaClasse *Moimeme = (MaClasse*)param;
}

Avec this passé en paramètre dans le CreateThread.

Pour éviter de se taper tout plein de «MaClasse->», vous pouvez tout
simplement réduire ExecuteThread à l'appel d'une autre fonction membre:
dans .

DWORD WINAPI MaClasse::ExecuteTache(LPVOID param){
MaClasse *Moimeme = (MaClasse*)param;
return MoiMeme->FonctionThread();
}

Merci de vos indications. Je vais effectivement suivre vos conseils en
écrivant Deux fonctions, l'une static de type DWORD WINAPI, appelant la
deuxième qui contiendra le code effectif.

Merci pour les indications.
J'aimerais un complément d'informations. Ma classe Maclasse est un singleton
dont l'un des objectifs est de démarrer n tâches, via la méthode
ExecuteTache. Mon problème réside dans l'arrêt de mon thread ExecuteTache
(CloseHandle() ), que je ne peux éxécuter de la classe démarrante
(DemarreTache() ). Est-ce que je peux finaliser ma tâche directement depuis
ma méthode FonctionThread() comme ceci:

class MaClasse{

private:
HANDLE Htache;
DWORD IdTache;

public:
MaClasse();
~MaClasse();
int DemarreTache();
static DWORD WINAPI ExecuteTache(LPVOID param); //methode qui
execute FonctionThread() dans un thread
int FonctionThread(); //fonction qui éxécute la tache
};//fin de MaClasse

int MaClasse::DemarreTache(){

TacheEnCours=CreateThread(0,0,ExecuteTache,(LPVOID)param,0,&IdTache);
}
//------------------------

DWORD WINAPI MaClasse::ExecuteTache(LPVOID param){
MaClasse *Moimeme = (MaClasse*)param;
return MoiMeme->FonctionThread();
}

int MaClasse::FonctionThread(){

//diverses actions
CloseHandle(TacheEnCours);


}

"Nicolas ROBERT" <nicolas.robert@prospective-software.fr> a écrit dans le
message de news:ch4ptj$el6

(DemarreTache() ). Est-ce que je peux finaliser ma tâche directement

depuis

ma méthode FonctionThread() comme ceci:

Pas ideal : le mieux est d'informer le thread qu'il doit se terminer. C'est
moins "sale"

F.

D'après Nicolas ROBERT:

int MaClasse::FonctionThread(){

//diverses actions
CloseHandle(TacheEnCours);


}

Est-ce vraiment ce que vous vouliez faire ?
La sortie de cette fonction entraine la sortie de la fonction qui l'a
appelée, donc du fil d'exécution.

Le CloseHandle est inutile.


Si vous voulez contrôler un fil de l'«extérieur», utilisez deux (voire plus)
nouvelles variables membres.

Par exemple:
bool FilEnCours, StopFil;

avec

int MaClasse::FonctionThread()
{
FilEnCours=true;
while(!StopFil)
{}
FilEnCoursúlse;

return 0;

}

et par exemple :
MaClasse::~MaClasse(){

StopFil = true;
while(FilEnCours);
}


Complétez avec une gestion de delai maximum (Timeout), pour éviter de rester
coincé et qui appelle dans ce cas le CloseHandle() sus-cité.