测试简单的asio异步服务过程

#include "stdafx.h"
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <stdexcept>
#include <boost/asio.hpp>
#include <vector>
#include <thread>
#include <chrono>

using namespace std;
using namespace boost;

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

string make_time()
{
    time_t tm = time(0);
    return ctime(&tm);
}

class tcp_connection
{
public:
    typedef std::shared_ptr<tcp_connection> pointer;
    static pointer create(asio::io_service& io_service)
    {
        return pointer(new tcp_connection(io_service));
    }

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


    /*
    void ReadThread()
    {
        while( socket_.is_open())
        {
            socket_.async_read_some(boost::asio::buffer(readMsg, 5),
                                        [=](boost::system::error_code err, size_t byte_trans)
                                        {
                                           handle_read(err, byte_trans);
                                        }
                                    );

            this_thread::sleep_for(std::chrono::milliseconds(5));
        }
    }
    */

    void start()
    {
        message_ = make_time();
        asio::async_write(socket_, asio::buffer(message_),
                          [=](boost::system::error_code err, size_t byte_trans)
                            {
                                handle_write(err, byte_trans);
                            }
                         );

        //thread th([=]() {ReadThread(); });
        //thread th(&tcp_connection::ReadThread,this);
        //th.join();

    }

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

    void handle_write(boost::system::error_code err,size_t byte_trans)
    {
        cout <<"remote ip="<<socket_.remote_endpoint().address()
             <<" remote port="<<socket_.remote_endpoint().port()
             << " write len=" << byte_trans << endl;
    }

    void handle_read(const boost::system::error_code& error, std::size_t bytes_transferred)
    {
        cout << "read byte=" << bytes_transferred << endl;
    }

private:
    tcp::socket socket_;
    std::string message_;
    char readMsg[100]{ 0 };
};

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

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

        acceptor_.async_accept(new_connect->socket(),
                               [=](const boost::system::error_code& error)
                               {
                                   handle_accept(new_connect, error);
                               }
                              );
    }

    void handle_accept(tcp_connection::pointer new_connection, const boost::system::error_code& error)
    {
        if(!error)
        {
            vecConnected.push_back(new_connection);
            new_connection->start();
        }

        start_accept();
    }
private:
    asio::ip::tcp::acceptor acceptor_;
    std::vector<tcp_connection::pointer> vecConnected;

};

int main()
{
    try
    {
        asio::io_service ioSer;
        tcp_server tcpServer(ioSer);
        ioSer.run();
    }
    catch(std::exception& exc)
    {
        cout << exc.what() << endl;
    }


    getchar();
    return 0;
}