Threader la fonction d'une classe
Bonjour,
J'essaie actuellement de threader une fonction faisant partie d'une classe.
Quelques petites informations :
La classe créée une connexion, reçois des paquets et réagis en conséquence.
Voici son prototype :
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
|
class server
{
private :
char buffer[8000];
bool starter_check;
int erreur;
SOCKET sock;
SOCKADDR_IN sin;
#if defined (WIN32)
WSADATA WSAData;
#endif
queue<char> fileA;
handler *framework;
public :
//creation de la socket etc
server(int port, string ip_g);
// Destruction de la socket etc
~server();
// Boucle d'écoute
void listener(void *data);
// Envoie de donnees
void sendData(char *data_g);
// Vidage de la queue
int processQueue(); |
Mon code devrais fonctionner de la façon suivante :
1) Le constructeur créée la socket, puis fait un thread sur la fonction listener
2) la fonction listener() réceptionne les paquet et les stock dans la variable "fileA" (qui est de type queue<byte>
3) Pendant ce temps, je lance la fonction processQueue(), qui va peu à peu traiter les paquets et vider la queue
Malheureusement, le thread ne semble pas accepter ma fonction. En effet, quand je compile mon projet je reçois ce message d'erreur :
Code:
1
2
3
|
server.cpp: In constructor 'server::server(int, std::string)':
server.cpp:38: error: argument of type 'void* (server::)(void*)' does not match 'void* (*)(void*)' |
Voici le .cpp ( on sait jamais ) :
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
#include "network/server.h"
// ################################################
// ##
// ## Configuration de la socket
// ## Connexion
// ## Destruction
// ##
// ################################################
server::server(int port, string ip_g)
{
framework = new handler();
#if defined (WIN32)
erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
#else
erreur = 0;
#endif
if(!erreur)
{
// create socket
sock = socket(AF_INET, SOCK_STREAM, 0);
// Connection configuration
sin.sin_addr.s_addr = inet_addr(ip_g.c_str());
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
// If connection
if(connect(sock, (SOCKADDR*)&sin, sizeof(sin)) != SOCKET_ERROR)
{
pthread_t thread;
// Permet d'exécuter le fonction maFonction en parallèle
pthread_create(&thread, NULL, listener, NULL);
processQueue();
starter_check = true;
}
else
starter_check = false;
}
else
starter_check = false;
}
server::~server()
{
closesocket(sock);
#if defined (WIN32)
WSACleanup();
#endif
}
// ################################################
// ##
// ## Creation de la boucle d'écoute
// ## Processus de vidage de la queue
// ##
// ##
// ################################################
void *server::listener(void *data_g)
{
int ok;
while(true)
{
// Reception des données
ok = recv(sock, buffer, sizeof(buffer), 0);
// Envoie des données dans la queue ("fileA" étant la queue)
for(int i = 0;i<ok;i++)
{
fileA.push(buffer[i]);
}
}
return NULL;
}
void server::sendData(char *data_g)
{
int ok = send(sock, data_g, sizeof(data_g), 0);
}
int server::processQueue()
{
while(fileA.size() > 0)
{
// Recupération du contenu et vidage de la queue
}
return 0;
} |
Merci d'avance.
