Boost.Asio c++ 网络编程翻译（16）

class talk_to_client : public boost::enable_shared_from_this<talk_to_
   client>

                        , boost::noncopyable {
       typedef talk_to_client self_type;

       talk_to_client() : sock_(service), started_(false) {}
   public:

       typedef boost::system::error_code error_code;
       typedef boost::shared_ptr<talk_to_client> ptr;

       void start() {
           started_ = true;

do_read(); }

       static ptr new_() {
           ptr new_(new talk_to_client);
           return new_;

       }
       void stop() {

           if ( !started_) return;
           started_ = false;
           sock_.close();

       }
       ip::tcp::socket & sock() { return sock_;}
       ...

   private:
       ip::tcp::socket sock_;
       enum { max_msg = 1024 };
       char read_buffer_[max_msg];
       char write_buffer_[max_msg];
       bool started_;

};

void on_read(const error_code & err, size_t bytes) {
       if ( !err) {

           std::string msg(read_buffer_, bytes);

           do_write(msg + "\n");
       }

stop(); }

   void on_write(const error_code & err, size_t bytes) {
       do_read();

}

ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(),
   8001));
   void handle_accept(talk_to_client::ptr client, const error_code & err)
   {

       client->start();
       talk_to_client::ptr new_client = talk_to_client::new_();
       acceptor.async_accept(new_client->sock(),

           boost::bind(handle_accept,new_client,_1));

   }
   int main(int argc, char* argv[]) {

       talk_to_client::ptr client = talk_to_client::new_();
       acceptor.async_accept(client->sock(),

           boost::bind(handle_accept,client,_1));
       service.run();

} 

ip::udp::endpoint ep( ip::address::from_string("127.0.0.1"), 8001);
   void sync_echo(std::string msg) {

       ip::udp::socket sock(service, ip::udp::endpoint(ip::udp::v4(), 0)
   );

       sock.send_to(buffer(msg), ep);
       char buff[1024];
       ip::udp::endpoint sender_ep;
       int bytes = sock.receive_from(buffer(buff), sender_ep);
       std::string copy(buff, bytes);

       std::cout << "server echoed our " << msg << ": "
                   << (copy == msg ? "OK" : "FAIL") << std::endl;

       sock.close();
   }

   int main(int argc, char* argv[]) {
       char* messages[] = { "John says hi", "so does James", "Lucy got

   home", 0 };
       boost::thread_group threads;
       for ( char ** message = messages; *message; ++message) {

           threads.create_thread( boost::bind(sync_echo, *message));

           boost::this_thread::sleep( boost::posix_time::millisec(100));
       }

       threads.join_all();
   }

io_service service;
   void handle_connections() {

       char buff[1024];

       ip::udp::socket sock(service, ip::udp::endpoint(ip::udp::v4(),
   8001));

       while ( true) {
           ip::udp::endpoint sender_ep;
           int bytes = sock.receive_from(buffer(buff), sender_ep);
           std::string msg(buff, bytes);
           sock.send_to(buffer(msg), sender_ep);

} }

   int main(int argc, char* argv[]) {
       handle_connections();

}