Discussion :

[LinuxUser]

Bonjour,

Je souhaiterais savoir comment utiliser les pthread pour appeler une fonction membre de ma classe.

Voici schematiquement ce que je voudrais faire:


.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <pthread.h>
 
struct pthread_data
{
  double a;
  double b;
  double c;
}
class MyClass
{
  void anotherMemberFunction();
  void memberFunctionToCall(double a, double b, double c);
 
  static void *threadHandler(void *args);
 
  struct pthread_data m_threads[2];
}

.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "MyClass.h"
void MyClass::anotherMemberFunction()
{
  ...
  iret1 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[1]);
  iret2 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[2]);
  ...
}
 
void *MyClass::threadHandler(void *args)
{
  struct pthread_data *data;
  data = (struct pthread_data*) args;
 
  memberFunctionToCall(data->a, data->b, data->c);
}

J'obtiens l'erreur suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

erreur: cannot call member function ‘void MyClass::memberFunctionToCall(double&, double&, double&)’ without object

J'insiste sur le fait que je souhaite appeler la function "memberFunctionToCall" avec l'objet courant (et toutes les valeurs de ses membres au moment de l'appel) et donc éviter toute solution qui créerait un objet juste pour effetuer l'appel, du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void handler(void *args)
{
 MyClass c;
 c.memberFunctionToCall(...);
}

Merci de votre aide.

[esired]

Bonsoir. La fonction threadHandler() étant déclaré static, je ne pense pas qu'il soit possible d'y faire appel memberFunctionToCall qui n'est pas static.
La solution serait peut être d'ajouter à la struct pthread_data un membre de type MyClass*

[esired]

La solution est donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
class MyClass;
 
struct pthread_data
{
  double a;
  double b;
  double c;
  MyClass *o; // Représentera un pointeur sur l'objet courant
};
 
class MyClass
{
  void anotherMemberFunction();
  void memberFunctionToCall(double a, double b, double c, MyClass *o);
 
  static void *threadHandler(void *args);
 
  struct pthread_data m_threads[2];
}
 
void *MyClass::threadHandler(void *args)
{
  struct pthread_data *data;
  data = (struct pthread_data*) args;
 
  memberFunctionToCall(data->a, data->b, data->c, data->o);
}

[bacelar]

C'est plus :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void *MyClass::threadHandler(void *args)
{
  struct pthread_data *data;
  data = reintrepret_cast<struct pthread_data*> args;
 
  data->o->memberFunctionToCall(data->a, data->b, data->c, data->o);
}

Mais faut ajouter les vérifications habituelles.

[LinuxUser]

Merci pour vos réponses, mais c'est le genre de solution que je voulais éviter.

D'ailleurs je vois pas comment utiliser cela lors de l'appel à thread_create:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
m_threads[1]->o = ?; // this?
iret1 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[1]);

[esired]

@bacelar
@LinuxUser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
m_threads[1]->o = this;

Je pense que c'est cela.
Cela dit, il y a un autre problème caché dans votre code. Avec la déclaration

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
struct pthread_data m_threads[2];

et ensuite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
iret2 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[2]); // c'est plutôt &m_threads[0] et ensuite &m_threads[1]

Ca sent la SEGFAULT

[LinuxUser]

Oui, c est une erreur d'inattention, je me suis juste trompé d'indice, il fallait lire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 iret1 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[0]);
  iret2 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[1]);

Par contre, je suis pas persuadé pour le "this" lors de l'appel .

[LittleWhite]

Bonjour,

J'ai une technique "bizarre" pour les threads POSIX en C++. Je passe un pointeur de la classe à mon thread et bien sur, comme il a été transformé en void*, je le caste dans le thread -> https://code.google.com/p/lpowerprob...ntation.cpp#43
(On remarquera une possible erreur avec l'assert, mais bon... passons.)
Et aussi, je mets en tant qu'amie, la fonction qui est lancée dans le thread -> https://code.google.com/p/lpowerprob...imentation.hpp ainsi, j'ai accès à mes fonctions/variables membres, une fois que je retourne dans ma classe, tranquillement.

[LinuxUser]

Donc dans mon cas, il faudrait:

1. Que j'ajoute un pointeur de ma classe dans la structure:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
struct pthread_data
{
  double a;
  double b;
  double c;
  MyClass *o; // Représentera un pointeur sur l'objet courant
};

2. Que je vire le "static" de ma fonction appelée dans le thread "threadHandler":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void *threadHandler(void *args); // static supprimé

C'est bien cela?

3. Que j'ajoute le mot clef friend à la place du static supprimé en 2.:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

friend void *threadHandler(void *args); // friend ajouté

Puis que j'appelle de la manière suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
m_threads[1]->o = this;
iret1 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[0]);

[Bousk]

Et aussi, je mets en tant qu'amie, la fonction qui est lancée dans le thread

Perso je la mets carrément membre static

[LinuxUser]

C'etait en static, mais lors de l'appel de la fonction membre à l'interieur de cette fonction, j'obtiens le message suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

erreur: cannot call member function ‘void MyClass::memberFunctionToCall(double&, double&, double&)’ without object

C'est le problème que j'ai à l'origine.

[esired]

Vous avez fait comme l'a dit bacelar ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
struct pthread_data
{
  double a;
  double b;
  double c;
  MyClass *o; // Représentera un pointeur sur l'objet courant
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class MyClass
{
  void anotherMemberFunction();
  void memberFunctionToCall(double a, double b, double c); // Plus besoin du paramètre de type MyClass*
 
  static void *threadHandler(void *args);
 
  struct pthread_data m_threads[2];
}

Ensuite dans la fonction membre static

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
void *MyClass::threadHandler(void *args)
{
  struct pthread_data *data;
  data = reintrepret_cast<struct pthread_data*> args;
 
  data->o->memberFunctionToCall(data->a, data->b, data->c); // 
}

Cela devrait normalement marcher...

[LinuxUser]

Pour mettre l'objet dans al structure, c'est quoi la bonne méthode, simplement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

m_threads[1]->o = this;

Ou est-ce qu il faut d'abord alloué la mémoire pour copier l'objet avant, du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
m_threads[1]->o = new Class;
m_threads[1]->o = this;

[esired]

Pour mettre l'objet dans la structure, comme vous dites c'est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
m_threads[1]->o = this;

[LinuxUser]

Ca ne marche pas, cela provoque une "seg fault".

[esired]

OK. Les threads doivent fonctionner sur un objet particulier ou avec plusieurs objets ?

[LinuxUser]

Un seul objet, l'objet courant de ma classe:

MyClass.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <pthread.h>
 
 
class MyClass
{
  ...
  struct pthread_data
 {
    double a;
    double b;
    double c;
    MyClass *pMyClass;
  }
}

MyClass.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void MyClass::anotherMemberFunction()
{
  ...
  m_threads[0]->o = ???; // je ne sais pas comment récupérer l'objet courant MyClass tout en allouant l'espace mémoire dans la structure
  iret1 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[0]);
  ...
  m_threads[1]->o = ???; // idem
  iret2 = pthread_create( &thread1, NULL, MyClass::threadHandler,
						(void*) &m_threads[1]);
  ...
}

[LinuxUser]

En fait la seg fault venait du fait que je m'étais trompé d'indice dans mon tableau de structure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
m_threads[1] au lieu de m_threads[0]
m_threads[2] au lieu de m_threads[1] // seg fault!!!

Donc là, je n'ai plus de seg fault, mais mes résultas sont faux, je ne sais pas si c'est un problème de synchronisation où de partage de mémoire (les deux objets travaillent sur le même objet alors qu ils devraient avoir chacun leur copie).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
m_threads[0]->o = this;
m_threads[1]->o = this;

Devrait peut être :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
m_threads[0]->o = ???; // copie objet courant
m_threads[1]->o = ???;// copie objet courant

[esired]

En fait la seg fault venait du fait que je m'étais trompé d'indice dans mon tableau de structure

Je l'avais dis ça...
Plus sérieusement si la fonction membre memberFunctionToCall modifie l'état de l'objet, il est normal que les deux threads concurrentiellement accèdent à l'objet alors qu'il est dans un état incorrect

[LittleWhite]

Perso je la mets carrément membre static

Je n'aime pas, car je veux garder accès aux autres fonctions/membres, de la classe. À moins que vous ne parliez de la fonction appelée par pthread_create (le pthread_handler) ?