asio_echo_server.cpp

#include <iostream>
#include <memory>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;

class session
	:public std::enable_shared_from_this<session>
{
private:
	tcp::socket socket_;

	enum { max_length = 1024 };
	char data_[max_length];

public:
	session(tcp::socket socket)
		: socket_{ std::move(socket) }
	{}

	void start() {
		this->do_read();
	}
private:
	void do_read() {
		auto self = shared_from_this();
		socket_.async_read_some(
			boost::asio::buffer(data_, max_length),
			[this, self](boost::system::error_code ec, std::size_t length) {
			if (ec) return;
			do_write(length);
		}
		);
	}

	void do_write(std::size_t length) {
		auto self = shared_from_this();
		boost::asio::async_write(socket_,
			boost::asio::buffer(data_, length),
			[this, self](boost::system::error_code ec, std::size_t) {
			if (ec) return;
			do_read();
		}
		);
	}
};

class server {
private:
	tcp::acceptor acceptor_;
	tcp::socket socket_;
public:
	server(boost::asio::io_service& io_service, short port)
		:acceptor_{ io_service, tcp::endpoint(tcp::v4(), port) },
		socket_{ io_service }
	{
		do_accept();
	}

private:
	void do_accept() {
		acceptor_.async_accept(socket_,
			[this](boost::system::error_code ec) {
			do {
				if (ec) break;
				std::make_shared<session>(std::move(socket_))->start();
			} while (false);

			do_accept();
		});
	}
};


int main()
{
	try {
		boost::asio::io_service io_service;

		server s(io_service, 8080);
		io_service.run();
	}
	catch (std::exception& e) {
		std::cout << "Exception:" << e.what() << std::endl;
	}

	return 0;
}