bonjour,

J'essaie de comprendre les diff�rents tutorial pour avoir un client et un server multithread asynchronique.
En gros j'aimerai que quand l'un ou l'autre envoie une infos, cela ouvre un thread jusqu'a ce que l'�change soit termin� pendant que d'autre �change(thread) soient donc possible asynchroniquement.

Donc j'ai chercher sur le net les diff�rents examples... :
https://www.boost.org/doc/libs/1_77_...cho_server.cpp
https://www.bogotobogo.com/cplusplus...ronizing_C.php
https://think-async.com/Asio/boost_a...tuttimer5.html
(website non s�curis�) https://dens.website/tutorials/cpp-asio/multithreading

mais franchement je ne comprends pas vraiment la m�thode.
disons qu'avec boost::asio, les classes ou fonctions peuvent avec 1 ou plus arguments, arguments qui peuvent �tre tel ou tel variable/constante et m�me en copiant un exemple d'un des tutos pour l'initialisation d'une fonction, je me retrouve quand m�me avec des erreurs si ce n'est des warnings.


mon dernier essaie est pour le code cot� client, je m'inspire du echo server histoire d'avoir une info � envoy� pour tester si cela fonctionne avec le serveur et du timer pour la methode mais de toutes fa�on je ne compile pas, bref...

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
 
#ifndef MFCHANFLER_H
#define MFCHANDLER_H
 
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <WinSock2.h>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
 
using namespace std;
using boost::asio::ip::udp;
 
class handler
{
private:
 
    udp::socket socket_;
    udp::resolver resolver_;
    udp::resolver::results_type endpoints_
        = resolver_.resolve(udp::v4(), "127.0.0.1", "3333");
    udp::endpoint server_endpoint;
    boost::asio::io_context::strand m_strand;
 
public:
 
    enum { max_length = 1024 };
    char sdata_[max_length];
    char rdata_[max_length];
 
 
    handler(boost::asio::io_service& io)
        :socket_(io), resolver_(io), m_strand(io)
    {
        m_strand.wrap(boost::bind(&handler::send, this));
        m_strand.wrap(boost::bind(&handler::receive, this));
    }
 
    void send()
    {
        cout << "send something" << endl;
        std::cin.getline(sdata_, max_length);
        size_t sdata_length = std::strlen(sdata_);
        socket_.async_send(boost::asio::buffer(sdata_, sdata_length), *endpoints_.begin());
        m_strand.wrap(boost::bind(&handler::send, this));
    }
 
    void receive()
    {
        cout << "receive something" << endl;
        socket_.async_receive(boost::asio::buffer(rdata_, max_length), server_endpoint);
        cout << rdata_ << endl;
        m_strand.wrap(boost::bind(&handler::receive, this));
    }
};
 
#endif
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
 
int main()
{
    try
    {        
        boost::asio::io_context io;
        handler h(io);
        boost::thread t(boost::bind(&boost::asio::io_service::run, &io));
        io.run();
        t.join();
    system("pause");
 
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }
 
    return 0;
}

Bref, est-ce que quelqu'un peut m'expliquer ou m'orienter vers un autre tutorial peut-�tre, je suis un peu perdu l�.
merci.


edit: Je vais essayer de revoir des tutos simplement sur les threads pour adapter une classe thread pour les send et receive de l'exemple echo client/serveur.
de ce que j'ai compris le strand permet de gerer le cot� asynchronique des thread, les organiser, pour qu'ils s'enchaines les uns apr�s les autres mais la m�thode avec bind m'�chappe.(j'fais pas mal de trucs en m�me temps, c'est pas �vident)