Asynchronous read/write operations

    Since async_send and async_receive functions will return immediately, and not block current thread, you should pass a callback function as the parameter which receives the result of read/write operations: 

    1. void handler(
    2.     const boost::system::error_code& error, // Result of operation.
    3.     std::size_t bytes_transferred           // Number of bytes processed.
    4. )

    There is a simple client/server example. Below is client code: 

    1. #include <boost/asio.hpp>
    2. #include <functional>
    3. #include <iostream>
    4. #include <memory>
    6. void callback(
    7.         const boost::system::error_code& error,
    8.         std::size_t bytes_transferred,
    9.         std::shared_ptr<boost::asio::ip::tcp::socket> socket,
    10.         std::string str)
    11. {
    12.     if (error)
    13.     {
    14.         std::cout << error.message() << '\n';
    15.     }
    16.     else if (bytes_transferred == str.length())
    17.     {
    18.         std::cout << "Message is sent successfully!" << '\n';
    19.     }
    20.     else
    21.     {
    22.         socket->async_send(
    23.                 boost::asio::buffer(str.c_str() + bytes_transferred, str.length() - bytes_transferred),
    24.                 std::bind(callback, std::placeholders::_1, std::placeholders::_2, socket, str));
    25.     }
    26. }
    29. int main()
    30. {
    31.     try
    32.     {
    33.         boost::asio::io_context io_context;
    35.         boost::asio::ip::tcp::endpoint endpoint{
    36.                 boost::asio::ip::make_address("192.168.35.145"),
    37.                 3303};
    41.         std::cout << "Connect to " << endpoint << " successfully!\n";
    43.         std::string str{"Hello world!"};
    44.         socket->async_send(
    45.                 boost::asio::buffer(str),
    46.                 std::bind(callback, std::placeholders::_1, std::placeholders::_2, socket, str));
    47.         socket->get_executor().context().run();
    48.     }
    49.     catch (std::exception& e)
    50.     {
    51.         std::cerr << e.what() << '\n';
    52.         return -1;
    53.     }
    55.     return 0;
    56. }

    Let’s go through the code:

    (1) Since socket object is non-copyable (please refer socket), socket is created as an shared pointer: 

    1. ......
    2. std::bind(callback, std::placeholders::_1, std::placeholders::_2, socket, str)
    3. ......

    (3) async_send does not guarantee all the bytes are sent (boost::asio::async_write returns either all bytes are sent successfully or an error occurs), so needs to reissue async_send in callback: 

    1. ......
    2. if (error)
    3. {
    4.     ......
    5. }
    6. else if (bytes_transferred == str.length())
    7. {
    8.     ......
    9. }
    10. else
    11. {
    12.     socket->async_send(......);
    13. }

    (4) io_context.run function will block until all work has finished and there are no
    more handlers to be dispatched, or until the io_context has been stopped:

    If there is no io_context.run function, the program will exit immediately.

    Check the server code who uses async_receive: 

    1. #include <ctime>
    2. #include <functional>
    3. #include <iostream>
    4. #include <string>
    5. #include <boost/asio.hpp>
    8.         const boost::system::error_code& error,
    9.         char recv_str[]) {
    10.     if (error)
    11.     {
    12.         std::cout << error.message() << '\n';
    13.     }
    14.     else
    15.     {
    16.         std::cout << recv_str << '\n';
    17.     }
    18. }
    20. int main()
    21. {
    22.     try
    23.     {
    24.         boost::asio::io_context io_context;
    26.         boost::asio::ip::tcp::acceptor acceptor(
    27.                                         io_context,
    28.                                         boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 3303));
    30.         for (;;)
    31.         {
    32.             boost::asio::ip::tcp::socket socket(io_context);
    33.             acceptor.accept(socket);
    35.             char recv_str[1024] = {};
    36.             socket.async_receive(
    37.                     boost::asio::buffer(recv_str),
    38.                     std::bind(callback, std::placeholders::_1, std::placeholders::_2, recv_str));
    39.             socket.get_executor().context().run();
    40.             socket.get_executor().context().restart();
    41.         }
    42.     }
    43.     catch (std::exception& e)
    44.     {
    45.         std::cerr << e.what() << std::endl;
    46.     }
    48.     return 0;
    49. }

    (1) Just for demo purpose: for every client, the callback is called only once;
    (2) io_context.restart must be called to invoke another io_context.run.

    Correspondingly, you can also check how to use boost::asio::async_read.

    Build and run programs. Client outputs following: 

    1. $ ./client
    2. Message is sent successfully!

    Server outputs following: