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

来源：互联网发布：酒店网络销售代理协议编辑：程序博客网时间：2024/05/17 05:10

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

0 0