Boost库-asio-异步客户端与服务端

 客户端类定义文件 ClientAsync.hpp

#ifndef __Client_Async_hpp__
#define __Client_Async_hpp__

#include<iostream>
#include<boost\asio.hpp>
#include<boost\bind.hpp>

class ClientAsync
{
	typedef ClientAsync this_type;
	typedef boost::asio::ip::tcp::endpoint endpoint_type;
	typedef boost::asio::ip::address address_type;
	typedef boost::asio::ip::tcp::socket socket_type;
	typedef boost::asio::io_service io_service_type;
	typedef boost::shared_ptr<socket_type> sock_ptr;
	typedef std::vector<char> buffer_type;
private:
	io_service_type m_io;
	buffer_type m_buf;
	endpoint_type m_ept;
public:
	ClientAsync() :m_buf(100, 0),
		m_ept(address_type::from_string("127.0.0.1"), 4567)
	{
		Start( );
	}
	void Run( )
	{
		m_io.run( );
	}

	void Start()
	{
		sock_ptr sock(new socket_type(m_io));

		sock->async_connect(m_ept,
			boost::bind(&this_type::Connect_Handler,this,
				boost::asio::placeholders::error,sock)
		);
	}
	void Connect_Handler(const boost::system::error_code &ec,sock_ptr sock)
	{
		if (ec)
		{ return;}

		std::cout << "recive from" << sock->remote_endpoint().address();

		sock->async_read_some(boost::asio::buffer(m_buf),
			boost::bind(&this_type::Read_Handler,
				this,boost::asio::placeholders::error)
		);
	}

	void Read_Handler(const boost::system::error_code &ec)
	{
		if (ec)
			return;
		std::cout << &m_buf[0] << std::endl;
	}
};



#endif // !__Client_Async_hpp__

客户端的主函数文件：

#include"ClientAsync.hpp"

int main(int argc, char** argv)
{
	try {
		std::cout << "client start..." << std::endl;
		ClientAsync client;
		client.Run( );
	}
	catch(std::exception except){
		std::cout << except.what() << std::endl;
	}

	getchar();
}

服务端类定义文件 ServerAsync.hpp

#ifndef __Server_Async_hpp__
#define __Server_Async_hpp__

#include<boost\asio.hpp>
#include<boost\bind.hpp>

class ServerAsync
{
	typedef ServerAsync this_type;
	typedef boost::asio::ip::tcp::acceptor acceptor_type;
	typedef boost::asio::ip::tcp::endpoint endpoint_type;
	typedef boost::asio::ip::tcp::socket socket_type;
	typedef boost::asio::io_service io_service_type;
	typedef boost::shared_ptr<socket_type> sock_ptr;
private:
	io_service_type m_io;
	acceptor_type m_acceptor;
public:
	ServerAsync() : m_acceptor(m_io,
		endpoint_type(boost::asio::ip::tcp::v4(), 4567)
	                            )
	{
		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;
		}
		std::cout << "client:" <<
			sock->remote_endpoint().address() << std::endl;

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

		Accept();
	}

	void Write_Handler(const boost::system::error_code& ec)
	{
		std::cout << "send message success!" << std::endl;
	}



};



#endif

服务端主函数文件：

//#include<boost\asio.hpp>
#include<iostream>
#include"ServerAsync.hpp"
int main(int argc, char** argv)
{
	try
	{ 
		ServerAsync server;
		server.Run();
	}
	catch (std::exception except)
	{
		std::cout << except.what() << std::endl;
	}

	getchar();

	return 0;
}