Appel fonction member par pthread_create

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:

---

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:

---

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:

---

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:

---

1 2 3 4 5

void handler(void *args) { MyClass c; c.memberFunctionToCall(...); }

---

Merci de votre aide.

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*

La solution est donc

Code:

---

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); }

---

C'est plus :

Code:

---

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.

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:

---

1 2 3

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

---

@bacelar :ccool:
@LinuxUser

Code:

---

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:

---

1 2	struct pthread_data m_threads[2];

---

et ensuite

Code:

---

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 ;)

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

Code:

---

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 :(.

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.

Donc dans mon cas, il faudrait:

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

Code:

---

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:

---

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:

---

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

---

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

Code:

---

1 2 3

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

---

Citation:

---

Envoyé par LittleWhite

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 :P

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

Code:

---

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

---

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

Vous avez fait comme l'a dit bacelar ?

Code:

---

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:

---

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:

---

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...

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

Code:

---

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:

---

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

---

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

Code:

---

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

---

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

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

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

MyClass.h

Code:

---

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:

---

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]); ... }

---

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

Code:

---

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:

---

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

---

Devrait peut être :

Code:

---

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

---

Citation:

---

Envoyé par LinuxUser

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

---

:mouarf::mouarf: 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

Citation:

---

Envoyé par Bousk

Perso je la mets carrément membre static :P

---

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) ?

Je ne reviens pas sur comment passer l'objet en paramètre, la question a été adressée correctement. En revanche, il faut être rigoureux sur la gestion du cycle de vie des objets :
- Si chaque thread doit avoir son objet, alors il ne faut pas stocker this qui est à chaque fois un pointeur vers le même objet. Il faut en créer un nouveau pour chaque thread.
- L'objet est-il toujours en vie lorsque les threads s'exécutent ? Si l'objet est créé avant de lancer les threads et détruit alors que ceux-ci s'exécutent encore, tu vas avoir des ennuis. Le code montré ne permet pas de savoir si c'est le cas ou pas.

Lorsque je vois ça, j'ai l'impression que tu manques de maîtrise sur la notion de pointeur :

Code:

---

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

---

Ca c'est fuite de mémoire direct. m_threads[1]->o = this est une copie de pointeur, ça n'affecte pas les objets pointés.

N'oublie pas de passer un memory checker sur ton exécutable, car on fait vite des erreurs avec ce genre de code.

Citation:

---

les deux objets travaillent sur le même objet alors qu ils devraient avoir chacun leur copie

---

Moi, je suis très très dubitatif sur l'architecture générale qui nécessite cela.
Si vous pouvez vous contenter d'un simple objet MyClass "vierge" comme objet de contexte, j'aurais fais une fonction libre qui créerait cet objet en début de fonction, et puis c'est tout.:weird:

Sinon, en C++11, std::thread :
http://stackoverflow.com/questions/1...ember-function

Citation:

---

Envoyé par LittleWhite

Je n'aime pas, car je veux garder accès aux autres fonctions/membres, de la classe.

---

Tu n'aimes pas alors que c'est strictement équivalent ? :calim2:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

class A { public: static void CB(void* arg) { A* pThis = (A*)arg; pThis->Do(); std::cout<<pThis->str<<pThis->s; pThis->Dodo(); }   void StartThread() { pthread_create( &thread1, NULL, A::CB, this); }   void Do() {} std::string str;   private: void Dodo() {} std::string s; };

---

Je vois pas ce qui pouvait être compris de travers .. et ce que tu as pu comprendre. :weird:

Bousk, c'est pas parce que c'est du code "low level" qui faut mettre des cast à la C dans du C++.
reinterpret_cast est ton ami.

@Bousk : c'est après, que je me suis rappelé que le compilateur ne fera pas son erreur de compilation, en disant que le pointeur de fonction n'est pas compatible avec ce que attend pthread_create(). Et oui, ainsi, je suis d'accord et je vais peut être changé ma version pour adopter la votre.

Citation:

---

Envoyé par bacelar

Bousk, c'est pas parce que c'est du code "low level" qui faut mettre des cast à la C dans du C++.
reinterpret_cast est ton ami.

---

static_cast plutôt quand il faut convertir vers/depuis du void*. En tout cas officiellement (à moins que cela ait changé en 2011; http://stackoverflow.com/a/311178/15934 ; et dans le n4296 je ne retrouve pas le patch évoqué ici: http://www.open-std.org/jtc1/sc22/wg...ects.html#1120) -- je soupçonne que c'est parce qu'il n'y a pas la garantie que sizeof(T*) == sizeof(void*) partout, plus autres problèmes d'alignements ; à re-vérifier éventuellement.

Sinon ... std/boost::thread, c'est bien aussi -- et il y avait la FAQ accessoirement: http://cpp.developpez.com/faq/cpp/?p...ur-de-fonction (au mauvais cast près)