boost daytime client/server

客户端连上服务器后， 服务器会返回一个当前日期时间给客户端。

// client.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <string>
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/noncopyable.hpp>

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

class tcp_client : public boost::noncopyable
{
public:
	explicit tcp_client(boost::asio::io_service& io)
		: socket_(io)
	{
	}

	boost::system::error_code connect(const std::string& ip,
		const std::string& port)
	{
		boost::system::error_code ec;
		tcp::resolver resolver(socket_.get_io_service());
		tcp::resolver::query query(ip, port);
		tcp::resolver::iterator endpoint_iter = resolver.resolve(query);
		boost::asio::connect(socket_, endpoint_iter, ec);
		return ec;
	}

	size_t read(std::string& str)
	{
		size_t nread = 0;
		const size_t read_once = 1024;
		for (;;)
		{
			boost::array<char, read_once> buf;
			boost::system::error_code error;

			size_t len = socket_.read_some(boost::asio::buffer(buf), error);

			if (error == boost::asio::error::eof)
			{
				break;
			}
			else if (error)
			{
				throw boost::system::system_error(error);
			}

			str += std::string(buf.data(), len);
			nread += len;
		}
		return nread;
	}

private:
	tcp::socket socket_;
};

int _tmain(int argc, _TCHAR* argv[])
{
	boost::asio::io_service io;
	tcp_client client(io);
	boost::system::error_code ec = client.connect("127.0.0.1", "6800");
	if (!ec)
	{
		std::string str;
		std::size_t len = client.read(str);
		std::cout << str << std::endl;
	}
	else
	{
		std::cerr << boost::system::system_error(ec).what() << std::endl;
	}

	system("pause");
	return 0;
}

// test.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <ctime>
#include <string>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>

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

std::string make_daytime_string()
{
	time_t now = time(NULL);
	return ctime(&now);
}

class tcp_connection
	: public boost::enable_shared_from_this<tcp_connection>
{
public:
	typedef boost::shared_ptr<tcp_connection> pointer;

	static pointer create(boost::asio::io_service& io_service)
	{
		return pointer(new tcp_connection(io_service));
	}

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

	void start()
	{
		message_ = make_daytime_string();

		boost::asio::async_write(socket_, boost::asio::buffer(message_),
			boost::bind(&tcp_connection::handle_write, shared_from_this(),
			boost::asio::placeholders::error,
			boost::asio::placeholders::bytes_transferred));
	}

private:
	tcp_connection(boost::asio::io_service& io_service)
		: socket_(io_service)
	{
	}

	void handle_write(const boost::system::error_code& e, size_t size)
	{
	}

	tcp::socket socket_;
	std::string message_;
};

class tcp_server
{
public:
	tcp_server(boost::asio::io_service& io_service)
		: acceptor_(io_service, tcp::endpoint(tcp::v4(), 13))
	{
		start_accept();
	}

private:
	void start_accept()
	{
		tcp_connection::pointer new_connection =
			tcp_connection::create(acceptor_.get_io_service());

		acceptor_.async_accept(new_connection->socket(),
			boost::bind(&tcp_server::handle_accept, this, new_connection,
			boost::asio::placeholders::error));
	}

	void handle_accept(tcp_connection::pointer new_connection,
		const boost::system::error_code& e)
	{
		if (!e)
		{
			new_connection->start();
		}
		start_accept();
	}

private:
	tcp::acceptor acceptor_;
};

int _tmain(int argc, _TCHAR* argv[])
{
	try
	{
		boost::asio::io_service io;
		tcp_server server(io);
		io.run();
	}
	catch (std::exception& e)
	{
		std::cerr << e.what() << std::endl;
	}

	system("pause");
	return 0;
}