Pourquoi les données ne transmettent-elles pas

Question

J'essaie de concevoir un programme de serveur client dans lequel les deux parties {serveur, client} peuvent communiquer avec async_connect. c'est mon code de programme serveur:

std::string GetMessage() 
{ 
    std::string user("User"); 
    user += client; 
    client++; 
    return user; 

} 

class TcpConnection 
     : public boost::enable_shared_from_this<TcpConnection> 
{ 
private: 
    boost::asio::ip::tcp::socket socket1; 
    std::string message; 


    TcpConnection(boost::asio::io_service &io_service) : 
      socket1(io_service) 
    { 
    } 

    void Writehandler(const boost::system::error_code &errorCode, size_t size) 
    { 
     if (!errorCode) 
     { 
      Read(); 
     } 
     std::cout << errorCode.message() << std::endl; 
    } 

public: 
    typedef boost::shared_ptr<TcpConnection> pointer; 

    static pointer Create(boost::asio::io_service &io_service) 
    { 
     return pointer(new TcpConnection(io_service)); 
    } 

    boost::asio::ip::tcp::socket &socket() 
    { 
     return socket1; 
    } 

    void Start() 
    { 
     message = GetMessage(); 
     boost::asio::async_write(socket(), boost::asio::buffer(message), 
           boost::bind(&TcpConnection::Writehandler, shared_from_this(), 
              boost::asio::placeholders::error, 
              boost::asio::placeholders::bytes_transferred)); 
    } 

    void Read() 
    { 
     std::array<char, 65> messages{}; 
     auto self(shared_from_this()); 
     boost::asio::async_read(socket(), 
           boost::asio::buffer(messages), 
           [this, self](boost::system::error_code ec, std::size_t /*length*/) { 
            if (!ec) { 
             Read(); 
            } else { 
             std::cout << ec.message() << std::endl; 
             exit(1); 
            } 
           }); 
    } 

}; 

class Server 
{ 
private: 
    boost::asio::ip::tcp::acceptor acceptor; 


public: 
    Server(boost::asio::io_service &io_service, unsigned short int port) 
      : 
      acceptor(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)) 
    { 
     startAccept(); 
    } 

    void startAccept() 
    { 
     TcpConnection::pointer newConnection = TcpConnection::Create(acceptor.get_io_service()); 
     acceptor.async_accept(newConnection->socket(), 
           boost::bind(&Server::Handler, this, newConnection, boost::asio::placeholders::error 
          )); 
    } 

    void Handler(TcpConnection::pointer &newConnection, const boost::system::error_code &errorCode) 
    { 
     if (!errorCode) 
      newConnection->Start(); 
     startAccept(); 
    } 
}; 

}

et voici mon code client:

class Client 
      : public boost::enable_shared_from_this<Client> 
    { 
    private: 
     boost::asio::ip::tcp::socket socket1; 
     std::string port; 

    public: 
     Client(boost::asio::io_service &io_service, std::string port) 
       : port(std::move(port)), 
        socket1(io_service) 
     { 
      start(); 
     } 

     void handler(const boost::system::error_code &errorCode, size_t size) 
     { 
     } 

     boost::asio::ip::tcp::socket &socket() 
     { 
      return socket1; 
     } 

     void start() 
     { 
      try 
      { 
       boost::asio::ip::tcp::resolver resolver(socket1.get_io_service()); 
       boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), port); 
       boost::asio::ip::tcp::resolver::iterator endpoint = resolver.resolve(query); 

       std::cout << exception.what() << std::endl; 
      } 
     } 

     void read() 
     { 
      std::array<char, 64> messages{}; 
      boost::asio::async_read(socket(), 
            boost::asio::buffer(messages.data(), messages.size()), 
            [this](boost::system::error_code ec, std::size_t /*length*/) 
            { 
             if (!ec) 
             { 
              read(); 
             } else 
             { 
              socket().close(); 
             } 
            }); 
     } 

     void write() 
     { 
      std::string message{}; 
      getline(std::cin, message, '\n'); 
      boost::asio::async_write(socket(), 
            boost::asio::buffer(message), 
            [this](boost::system::error_code ec, std::size_t /*length*/) 
            { 
             if (!ec) 
             { 
              write(); 

             } else 
             { 
              socket().close(); 
             } 
            }); 
     } 

    }; 

Le code est sans erreur. mais quand j'ai connecté les deux données en ne injectant pas.

Answer 1

Dans votre fonction Client::start, vous ne vous connectez jamais réellement à un serveur distant. Vous ne résolvez que l'adresse du partenaire distant.

boost::asio::connect ou boost::asio::async_connect pourrait être ce que vous voulez.

void start() 
{ 
    try 
    { 
     boost::asio::ip::tcp::resolver resolver(socket1.get_io_service()); 
     boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), port); 
     boost::asio::ip::tcp::resolver::iterator endpoint = resolver.resolve(query); 
     boost::asio::connect(socket(), endpoint); //<--- Connect to your server 

     std::cout << exception.what() << std::endl; 
    } 
    catch (const std::exception &e) 
    { 
     //Handle 
    } 
    catch (const boost::system::system_error &e) 
    { 
     //Handle 
    } 
} 

Vous pouvez également catch quelque chose avec votre bloc try. Je ne suis pas sûr quel compilateur vous permet de faire cela.

Il est également recommandé de créer le tampon de lecture en tant que membre de la classe.