boost 异步IO 服务端实例代码

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>

using namespace std;
using namespace boost::asio::ip;

class Connection: public boost::enable_shared_from_this<Connection> {
public:
	Connection(boost::asio::io_service& svc) :
			sock(svc) {

	}

	~Connection() {
		cerr << "~Connection()\n";
	}

	tcp::socket& socket() {
		return sock;
	}

	void startReceive() {
		cerr << "Connection::startReceive()\n";

		sock.async_read_some(boost::asio::buffer(buf, sizeof buf),
				boost::bind(&Connection::handleReceive, shared_from_this(), _1,
						_2));
	}

private:
	void handleReceive(const boost::system::error_code& ec, size_t bytes) {
		cerr << "Connection::handleReceive()\n";
		if (!ec) {
			boost::asio::async_write(sock, boost::asio::buffer(buf, bytes),
					boost::asio::transfer_all(),
					boost::bind(&Connection::handleSend, shared_from_this(),
							_1));

			sock.async_read_some(boost::asio::buffer(buf, sizeof buf),
					boost::bind(&Connection::handleReceive, shared_from_this(),
							_1, _2));
		} else {
			if (ec != boost::asio::error::eof)
				std::cerr << "sock.async_read_some(): An error occurred: "
						<< ec.message() << '\n';
		}
	}

	void handleSend(const boost::system::error_code& ec) {
		cerr << "Connection::handleReceive()\n";
		if (ec) {
			std::cerr << "async_write(): An error occurred: " << ec.message()
					<< '\n';
		}
	}

private:
	tcp::socket sock;
	char buf[512];
};

// ---------------------------------------------------------------------------

class Acceptor {
public:
	Acceptor(boost::asio::io_service& svc, unsigned short port) :
			acc(svc, tcp::endpoint(tcp::v4(), port)) {

	}

	void startAccept() {
		cerr << "Acceptor::startAccept()\n";
		boost::shared_ptr<Connection> con(new Connection(acc.get_io_service()));
		acc.async_accept(con->socket(),
				boost::bind(&Acceptor::handleAccept, this, _1, con));
	}

private:
	void handleAccept(const boost::system::error_code& ec,
			boost::shared_ptr<Connection> con) {
		cerr << "Acceptor::handleAccept()\n";
		if (!ec) {
			con->startReceive();

			con.reset(new Connection(acc.get_io_service()));
			acc.async_accept(con->socket(),
					boost::bind(&Acceptor::handleAccept, this, _1, con));
		} else
			std::cerr << "acc.async_accept(): An error occurred: "
					<< ec.message() << '\n';
	}

private:
	tcp::acceptor acc;
};

int main() {
	boost::asio::io_service svc;
	Acceptor acc(svc, 9988);

	acc.startAccept();

	svc.run();
}