Discussion :

[I-DEXX]

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.

[Invité]

Bonsoir,

Voir ce sujet de la FAQ :
Pourquoi ne peut-on pas passer une fonction membre là où on attend un pointeur de fonction ?

[I-DEXX]

Merci de ta réponse Winjerome,

Mais je reçois toujours une erreur :

Code :

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

1
2
3
 
error: invalid conversion from 'DWORD (*)(void*)' to 'void* (*)(void*)'
error:   initializing argument 3 of 'int pthread_create(pthread_t*, pthread_attr_t_* const*, void* (*)(void*), void*)'

Je ne vois pas du tout ce que je pourrais faire, une idée ?

[Invité]

Le DWORD de la FAQ n'était qu'un exemple, utilisé car la fonction CreateThread prend un pointeur sur une fonction qui en retourne un.
Dans ton cas, garde un retour de type void

[I-DEXX]

C'était en effet une erreur stupide de ma part

Mais en rectifiant le code je suis tombé sur le message d'erreur le plus bizarre qui soit :

Code :

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

1
2
 
error: invalid conversion from 'void* (*)(void*)' to 'void* (*)(void*)'

comment peut-il y avoir une erreur alors que les 2 types sont les mêmes ??!

[imperio]

Tu devrais appeler ta methode listener depuis la fonction threadee et non pas directement ta methode. Un truc dans le genre :

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
void *thread_func(void *c)
{
  server *s = static_cast<server*>(c);
 
  s->listener();
  return 0;
}
 
//constructeur de ta classe
server::server()
{
  ...
  pthread_create(&thread, NULL, thread_func, this);
  ...
}