Warum Daten nicht senden

Question

Ich versuche, ein Client-Server-Programm, in dem beide Partei {Server, Client} mit async_connect kommunizieren können. dies ist mein Server Programmcode:

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(); 
    } 
}; 

}

und dies ist mein Client-Code:

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(); 
             } 
            }); 
     } 

    }; 

Der Code ist fehlerfrei. aber wenn ich beide Daten in nicht injiziert.

Answer 1

In Ihrer Client::start Funktion verbinden Sie nie tatsächlich mit einem Remote-Server. Sie lösen nur die Adresse des entfernten Partners auf.

boost::asio::connect oder boost::asio::async_connect könnte was Sie wollen.

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 
    } 
} 

könnten Sie auch mit Ihrem try-Block catch etwas wollen. Ich bin mir nicht sicher, mit welchem ​​Compiler Sie das machen können.

Es wird auch empfohlen, den Lese-Puffer als Klassenmitglied zu erstellen.