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 : 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
 
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : 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
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.