使用Boost asio实现异步的TCP/IP通信

　　可以先了解一下Boost asio基本概念，以下是Boost asio实现的异步TCP/IP通信：

　　服务器：

#include "stdafx.h"

#include <iostream>

#include <boost/shared_ptr.hpp>

#include <boost/asio.hpp>

#include <boost/asio/placeholders.hpp>

#include <boost/system/error_code.hpp>

#include <boost/bind/bind.hpp>

using namespace boost::asio;

using namespace std;

class server

{

    typedef server this_type;

    typedef ip::tcp::acceptor acceptor_type;

    typedef ip::tcp::endpoint endpoint_type;

    typedef ip::tcp::socket socket_type;

    typedef ip::address address_type;

    typedef boost::shared_ptr<socket_type> sock_ptr;

private:

    io_service m_io;

    acceptor_type m_acceptor;

public:

    server() : m_acceptor(m_io, endpoint_type(ip::tcp::v4(), ))

    {    accept();    }

    void run(){ m_io.run();}

    void accept()

    {

        sock_ptr sock(new socket_type(m_io));

        m_acceptor.async_accept(*sock, boost::bind(&this_type::accept_handler, this, boost::asio::placeholders::error, sock));

    }

    void accept_handler(const boost::system::error_code& ec, sock_ptr sock)

    {

        if (ec)

        {    return;    }

        cout<<"Client:";

        cout<<sock->remote_endpoint().address()<<endl;

        sock->async_write_some(buffer("hello asio"), boost::bind(&this_type::write_handler, this, boost::asio::placeholders::error));

        // 发送完毕后继续监听，否则io_service将认为没有事件处理而结束运行

        accept();

    }

    void write_handler(const boost::system::error_code&ec)

    {

        cout<<"send msg complete"<<endl;

    }

};

int main()

{

    try

    {

        cout<<"Server start."<<endl;

        server srv;

        srv.run();

    }

    catch (std::exception &e)

    {

        cout<<e.what()<<endl;

    }

    return ;

}

　　客户端：

#include "stdafx.h"

#include <iostream>

#include <boost/shared_ptr.hpp>

#include <boost/asio.hpp>

#include <boost/asio/placeholders.hpp>

#include <boost/system/error_code.hpp>

#include <boost/bind/bind.hpp>

using namespace boost::asio;

using namespace std;

class client

{

    typedef client this_type;

    typedef ip::tcp::acceptor acceptor_type;

    typedef ip::tcp::endpoint endpoint_type;

    typedef ip::tcp::socket socket_type;

    typedef ip::address address_type;

    typedef boost::shared_ptr<socket_type> sock_ptr;

    typedef vector<char> buffer_type;

private:

    io_service m_io;

    buffer_type m_buf;

    endpoint_type m_ep;

public:

    client(): m_buf(, ), m_ep(address_type::from_string("127.0.0.1"), )

    {    start();    }

    void run()

    {    m_io.run();}

    void start()

    {

        sock_ptr sock(new socket_type(m_io));

        sock->async_connect(m_ep, boost::bind(&this_type::conn_handler, this, boost::asio::placeholders::error, sock));

    }

    void conn_handler(const boost::system::error_code&ec, sock_ptr sock)

    {

        if (ec)

        {return;}

        cout<<"Receive from "<<sock->remote_endpoint().address()<<": "<<endl;

        sock->async_read_some(buffer(m_buf), boost::bind(&client::read_handler, this, boost::asio::placeholders::error, sock));

    }

    void read_handler(const boost::system::error_code&ec, sock_ptr sock)

    {

        if (ec)

        {return;}

        sock->async_read_some(buffer(m_buf), boost::bind(&client::read_handler, this, boost::asio::placeholders::error, sock));

        cout<<&m_buf[]<<endl;

    }

};

int main()

{

    try

    {

        cout<<"Client start."<<endl;

        client cl;

        cl.run();

    }

    catch (std::exception &e)

    {

        cout<<e.what()<<endl;

    }

    return ;

}