boost::asio TCP客户端编程示例

view plaincopy to clipboardprint?
// testASIOClient.cpp : Defines the entry point for the console application.   
//   
 
#include "stdafx.h"   
 
#include <boost/asio.hpp>   
#include <boost/bind.hpp>   
#include <boost/lexical_cast.hpp>   
#include <iostream>   
 
using boost::asio::io_service;         
using boost::asio::ip::tcp;   
     
 
 
#define ASYNCHRONOUS   
 
#ifndef ASYNCHRONOUS   
class Client         
{         
public:         
       Client (const string & hostname, unsigned short port);         
       virtual ~Client ();         
       
       // methods         
       virtual void send (const string & message);         
       virtual string recv ();         
       virtual void close ();         
       
private:         
       io_service * io_service_;         
       tcp::socket * socket_;         
};         
       
Client::Client (const string & hostname, unsigned short port)         
{         
       io_service_ = new io_service();         
       socket_ = new tcp::socket(*io_service_);         
       
       tcp::resolver resolver(*io_service_);         
       tcp::resolver::query query(hostname, boost::lexical_cast<string, unsigned short>(port));         
       
       boost::system::error_code ec;         
       tcp::resolver::iterator iter = resolver.resolve(query, ec);         
       tcp::resolver::iterator end;         
       
       // pick the first endpoint         
       if (iter != end && ec == 0)         
       {         
               tcp::endpoint endpoint = *iter;         
               std::cout << "Connecting to: " << endpoint << std::endl;         
       
               socket_->connect(endpoint, ec);         
               if (ec)         
               {         
                       std::cerr << "Error: " << ec << std::endl;         
                       throw ec;         
               }         
       }         
}         
       
Client::~Client ()         
{         
       delete socket_;         
       delete io_service_;           
}         
       
void Client::send (const string & message)         
{         
       boost::asio::const_buffers_1 request(message.data(), message.size());         
       socket_->send(request);         
}         
       
string Client::recv ()         
{         
       char response[128];         
       size_t num = socket_->receive(boost::asio::buffer(response));         
       if (num > 0)         
       {         
               return string (response, num);         
       }         
       
       return "";         
}         
       
void Client::close ()         
{         
       socket_->close();         
                 
}         
 
int _tmain(int argc, _TCHAR* argv[])   
{   
       Client client ("localhost", 8100);         
       std::cout << client.recv() << endl;         
                         
       string request;         
       
       do         
       {         
               std::cout << "Request: ";         
                         
               std::cin >> request;         
                         
               if (request == "q")         
                       break;         
       
               client.send (request);         
       
               std::cout << "Response: " << client.recv() << endl;         
       }         
       while (true);         
                 
       client.close();         
       return 0;   
}   
#else   
 
#define _RECV_BUF_SIZE_ 1024   
 
class CClientASIO         
{         
public:         
       CClientASIO (const std::string & hostname, unsigned short port,io_service   * io_service_);   
       virtual ~CClientASIO();         
       
       // methods         
       virtual void PostSend (const std::string & message);   
 
       //event call   
       virtual bool OnRecv (const boost::system::error_code& error,size_t bytes_transferred);   
       virtual bool OnSend(const boost::system::error_code& error,size_t bytes_transferred);   
       virtual void OnClose (const boost::system::error_code& error);         
       
private:         
       io_service   * m_io_service;   
       tcp::socket * m_socket;     
       char                   m_data[_RECV_BUF_SIZE_];   
};         
       
CClientASIO::CClientASIO (const std::string & hostname, unsigned short port,io_service   * io_service_)         
{         
       m_io_service = io_service_;   
       m_socket         = new tcp::socket(*m_io_service);   
       
       tcp::resolver               resolver(*m_io_service);             
       boost::system::error_code ec;         
       tcp::resolver::query query(hostname, boost::lexical_cast<std::string, unsigned short>(port));         
       tcp::resolver::iterator iter = resolver.resolve(query, ec);         
       tcp::resolver::iterator end;         
       
       // pick the first endpoint         
       if (iter != end && ec == 0)         
       {         
               tcp::endpoint endpoint = *iter;         
 
               std::cout << "Connecting to: " << endpoint << std::endl;         
       
               m_socket->connect(endpoint, ec);     
               memset(m_data,0,sizeof(m_data));   
               m_socket->async_read_some(boost::asio::buffer(m_data,_RECV_BUF_SIZE_),   
                       boost::bind(&CClientASIO::OnRecv,this,   
                       boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred));   
               if (ec)         
               {         
                       std::cerr << "Error: " << ec << std::endl;         
                       throw ec;         
               }         
       }         
}         
       
CClientASIO::~CClientASIO()         
{         
       delete m_socket;         
       delete m_io_service;   
}         
       
void CClientASIO::PostSend(const std::string & message)     
{         
       m_socket->async_write_some(boost::asio::buffer(message.c_str(),message.size()),   
               boost::bind(&CClientASIO::OnSend,this,   
               boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred));   
}   
 
bool CClientASIO::OnRecv(const boost::system::error_code& error,size_t bytes_transferred)   
{   
               if(!error)   
               {   
                       std::string strRecv = (char *)m_data;   
                           
                       std::cout<<strRecv<<std::endl;         
 
                       memset(m_data,0,sizeof(m_data));   
                       m_socket->async_read_some(boost::asio::buffer(m_data,_RECV_BUF_SIZE_),   
                               boost::bind(&CClientASIO::OnRecv,this,   
                               boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred));   
               }   
               else 
               {   
                       OnClose(error);   
                       return false;   
               }   
               return true;   
}   
 
bool CClientASIO::OnSend(const boost::system::error_code& error,size_t bytes_transferred)   
{   
       std::cout<<"Send Bytes:"<<bytes_transferred<<std::endl;   
       if(error)   
       {   
               OnClose(error);   
               return false;   
       }   
       return true;   
}   
 
void CClientASIO::OnClose(const boost::system::error_code& error)   
{         
       m_socket->close();     
}         
 
int _tmain(int argc, _TCHAR* argv[])   
{   
       io_service io_service_;   
       CClientASIO c("127.0.0.1", 8100,&io_service_);       
       std::string strMsg="Hello,World!";   
       c.PostSend(strMsg);   
       io_service_.run();   
                         
       return 0;   
}   
 
#endif