asio库的使用2(Boost程序库完全开发指南)读书笔记

boost------asio库的使用2(Boost程序库完全开发指南)读书笔记

2013-08-02 13:52:44     我来说两句       作者：孤独的豆沙包

收藏    我要投稿

网络通信

http://blog.csdn.net/q601510717/article/details/7732643

asio库支持TCP、UDP、ICMP通信协议，它在名字空间boost::asio::ip里提供了大量的网络通信方面的函数和类，很好地封装了原始的Berkeley Socket Api，展现给asio用户一个方便易用且健壮的网络通信库。

 

ip::tcp类是asio网络通信(TCP)部分主要的类，但它本身并没有太多的功能，而是定义了数个用于TCP通信的typedef类型，用来协作完成网络通信。这些typedef包括端点类endpoint、套接字类socket、流类iostream，以及接收器acceptor、解析器resolver等等。从某种程度上来看，ip::tcp类更像是一个名字空间。

 

1、IP地址和端点
IP地址独立于TCP、UDP等通信协议，asio库使用类ip::address来表示IP地址，可以同时支持ipv4和ipv6两种地址。

[cpp]
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "iostream"  
using namespace std; 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    boost::asio::ip::address addr;          // 声明一个ip地址对象  
    addr = addr.from_string("127.0.0.1");   // 从字符串产生IP地址  
    assert(addr.is_v4());                   // ipv4的地址  
    cout << addr.to_string() << endl; 
 
    addr = addr.from_string("2000:0000:0000:0000:0001:2345:6789:abcd"); 
    assert(addr.is_v6()); 
    cout << addr.to_string() << endl; 
 
    return 0; 
} 

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "iostream"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
 boost::asio::ip::address addr;   // 声明一个ip地址对象
 addr = addr.from_string("127.0.0.1"); // 从字符串产生IP地址
 assert(addr.is_v4());     // ipv4的地址
 cout << addr.to_string() << endl;

 addr = addr.from_string("2000:0000:0000:0000:0001:2345:6789:abcd");
 assert(addr.is_v6());
 cout << addr.to_string() << endl;

 return 0;
}

 

有了IP地址，再加上通信用的端口号就构成了一个socket端点，在asio库中用ip::tcp::endpoint类来表示。它的主要用法就是通过构造函数创建一个可用于socket通信的端点对象，端点的地址和端口号可以用address()和port()获得：

 

[cpp]
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "iostream"  
using namespace std; 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    boost::asio::ip::address addr;          // 声明一个ip地址对象  
    addr = addr.from_string("127.0.0.1");   // 从字符串产生IP地址  
 
    boost::asio::ip::tcp::endpoint ep(addr, 6688); 
 
    assert(ep.address() == addr); 
    assert(ep.port() == 6688); 
 
    return 0; 
} 

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "iostream"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
 boost::asio::ip::address addr;   // 声明一个ip地址对象
 addr = addr.from_string("127.0.0.1"); // 从字符串产生IP地址

 boost::asio::ip::tcp::endpoint ep(addr, 6688);

 assert(ep.address() == addr);
 assert(ep.port() == 6688);

 return 0;
}

 

 

2、同步socket处理

ip::tcp的内部类型socket、acceptor和resolver是asio库TCP通信中最核心的一组类，它们封装了socket的连接、断开和数据收发功能，使用它们可以很容易地编写出socket程序。

 

socket类是TCP通信的基本类，调用成员函数connect()可以连接到一个指定的通信端点，连接成功后用local_endpoint()和remote_endpoint()获得连接两端的端点信息，用read_some()和write_some()阻塞读写数据，当操作完成后使用close()函数关闭socket。如果不关闭socket，那么在socket对象析构时也会自动调用close()关闭。

 

acceptor类对应socketAPI的accept()函数功能，它用于服务器端，在指定的端口号接受连接，必须配合socket类才能完成通信。

 

resolver类对应socketAPI的getaddrinfo()系列函数，用于客户端解析网址获得可用的IP地址，解析得到的IP地址可以使用socket对象连接。

 

下面是一个使用socket类和acceptor类来实现一对同步通信的服务器和客户端程序：

服务器端(它使用一个acceptor对象在6688端口接受连接，当有连接时使用一个socket对象发送一个字符串)：

 

server.cpp：

[cpp]
// server.cpp : 定义控制台应用程序的入口点。  
//  
 
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "iostream"  
using namespace std; 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    try 
    { 
        cout << "server start" << endl; 
        boost::asio::io_service ios; 
 
        boost::asio::ip::tcp::acceptor acceptor(ios,  
            boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 6688)); 
 
        cout << acceptor.local_endpoint().address() << endl; 
 
        while (true) 
        { 
            boost::asio::ip::tcp::socket sock(ios); 
            acceptor.accept(sock); 
 
            cout << "client : "; 
            cout << sock.remote_endpoint().address() << endl; 
 
            sock.write_some(boost::asio::buffer("hello asio")); 
        } 
    } 
 
    catch (std::exception& e) 
    { 
        cout << e.what() << endl; 
    } 
 
    return 0; 
} 

// server.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "iostream"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
 try
 {
  cout << "server start" << endl;
  boost::asio::io_service ios;

  boost::asio::ip::tcp::acceptor acceptor(ios,
   boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 6688));

  cout << acceptor.local_endpoint().address() << endl;

  while (true)
  {
   boost::asio::ip::tcp::socket sock(ios);
   acceptor.accept(sock);

   cout << "client : ";
   cout << sock.remote_endpoint().address() << endl;

   sock.write_some(boost::asio::buffer("hello asio"));
  }
 }

 catch (std::exception& e)
 {
  cout << e.what() << endl;
 }

 return 0;
}
服务器端程序里要注意的是自由函数buffer()，他可以包装很多种类的容器成为asio组件可用的缓冲区类型。通常不能直接把数组、vercor等容器用作asio的读写参数，必须使用buffer()函数包装

 

client：

[cpp]
// client.cpp : 定义控制台应用程序的入口点。  
//  
 
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "iostream"  
using namespace std; 
#include "vector"  
 
 
class AsynTimer 
{ 
public: 
    template<typename F>                              // 模板类型，可以接受任意可调用物  
    AsynTimer(boost::asio::io_service& ios, int x, F func) 
        :f(func), count_max(x), count(0),               // 初始化回调函数和计数器  
        t(ios, boost::posix_time::millisec(500))        // 启动计时器  
    { 
        t.async_wait(boost::bind(&AsynTimer::CallBack,  // 异步等待计时器  
            this, boost::asio::placeholders::error));   // 注册回调函数  
    } 
 
    void CallBack(const boost::system::error_code& error) 
    { 
        if (count >= count_max)   // 如果计数器达到上限则返回  
        { 
            return; 
        } 
        ++count; 
        f();                     // 调用function对象  
 
        // 设置定时器的终止时间为0.5秒之后  
        t.expires_at(t.expires_at() + boost::posix_time::microsec(500)); 
        // 再次启动定时器，异步等待  
        t.async_wait(boost::bind(&AsynTimer::CallBack, this, boost::asio::placeholders::error)); 
    } 
 
private: 
    int count; 
    int count_max; 
    boost::function<void()> f;        // function对象，持有无参无返回值的可调用物  
    boost::asio::deadline_timer t;  // asio定时器对象  
}; 
 
 
void client(boost::asio::io_service& ios) 
{ 
    try 
    { 
        cout << "client start." << endl; 
 
        boost::asio::ip::tcp::socket sock(ios); 
        boost::asio::ip::tcp::endpoint ep(boost::asio::ip::address::from_string("127.0.0.1"), 6688); 
 
        sock.connect(ep); 
 
        vector<char> str(100, 0); 
        sock.read_some(boost::asio::buffer(str)); 
 
        cout << "recive from" << sock.remote_endpoint().address(); 
        cout << &str[0] << endl; 
 
    } 
    catch (std::exception& e) 
    { 
        cout << e.what() << endl; 
    } 
} 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    boost::asio::io_service ios; 
    AsynTimer at(ios, 50000, boost::bind(client, boost::ref(ios))); 
    ios.run(); 
 
    return 0; 
} 

// client.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "iostream"
using namespace std;
#include "vector"

class AsynTimer
{
public:
 template<typename F>        // 模板类型，可以接受任意可调用物
 AsynTimer(boost::asio::io_service& ios, int x, F func)
  :f(func), count_max(x), count(0),    // 初始化回调函数和计数器
  t(ios, boost::posix_time::millisec(500))  // 启动计时器
 {
  t.async_wait(boost::bind(&AsynTimer::CallBack,  // 异步等待计时器
   this, boost::asio::placeholders::error)); // 注册回调函数
 }

 void CallBack(const boost::system::error_code& error)
 {
  if (count >= count_max)  // 如果计数器达到上限则返回
  {
   return;
  }
  ++count;
  f();      // 调用function对象

  // 设置定时器的终止时间为0.5秒之后
  t.expires_at(t.expires_at() + boost::posix_time::microsec(500));
  // 再次启动定时器，异步等待
  t.async_wait(boost::bind(&AsynTimer::CallBack, this, boost::asio::placeholders::error));
 }

private:
 int count;
 int count_max;
 boost::function<void()> f;  // function对象，持有无参无返回值的可调用物
 boost::asio::deadline_timer t; // asio定时器对象
};

void client(boost::asio::io_service& ios)
{
 try
 {
  cout << "client start." << endl;

  boost::asio::ip::tcp::socket sock(ios);
  boost::asio::ip::tcp::endpoint ep(boost::asio::ip::address::from_string("127.0.0.1"), 6688);

  sock.connect(ep);

  vector<char> str(100, 0);
  sock.read_some(boost::asio::buffer(str));

  cout << "recive from" << sock.remote_endpoint().address();
  cout << &str[0] << endl;

 }
 catch (std::exception& e)
 {
  cout << e.what() << endl;
 }
}

int _tmain(int argc, _TCHAR* argv[])
{
 boost::asio::io_service ios;
 AsynTimer at(ios, 50000, boost::bind(client, boost::ref(ios)));
 ios.run();

 return 0;
}

3、异步socket处理
我们把刚才的同步socket程序改为异步调用方式。异步程序的处理流程与同步程序基本相同，只需要把原有的同步调用函数都换成前缀是async_的异步调用函数，并增加回调函数，在回调函数中再启动一个异步调用

 

服务器端：

[cpp]
// server.cpp : 定义控制台应用程序的入口点。  
//  
 
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "iostream"  
using namespace std; 
 
 
class Server 
{ 
private: 
    boost::asio::io_service& ios; 
    boost::asio::ip::tcp::acceptor acceptor; 
    typedef boost::shared_ptr<boost::asio::ip::tcp::socket> sock_pt; 
 
public: 
    Server(boost::asio::io_service& io) : ios(io), 
        acceptor(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 6688)) 
    { 
        Start(); 
    } 
    ~Server() 
    { 
 
    } 
 
    void Start() 
    { 
        sock_pt sock(new boost::asio::ip::tcp::socket(ios));    // 智能指针  
 
        // 异步侦听服务  
        acceptor.async_accept(*sock, boost::bind(&Server::acceptor_handle,  
                                                 this, boost::asio::placeholders::error, sock)); 
    } 
 
    void acceptor_handle(const boost::system::error_code& error, sock_pt sock) 
    { 
        if (error) 
        { 
            return; 
        } 
        cout << "client : "; 
 
        // 输出连接的客户端信息  
        cout << sock->remote_endpoint().address() << endl; 
 
        //   
        sock->async_write_some( boost::asio::buffer("hello asio"),  
                                boost::bind(&Server::write_handle, 
                                this, boost::asio::placeholders::error)); 
 
        Start(); // 再次启动异步接受连接  
    } 
 
    void write_handle(const boost::system::error_code& error) 
    { 
        cout << "send message is complate" << endl; 
    } 
 
}; 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    try 
    { 
        cout << "server start." << endl; 
 
        boost::asio::io_service ios; 
 
        Server serv(ios); 
 
        ios.run(); 
    } 
    catch (std::exception& e) 
    { 
        cout << e.what() << endl; 
    } 
 
    return 0; 
} 

// server.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "iostream"
using namespace std;

class Server
{
private:
 boost::asio::io_service& ios;
 boost::asio::ip::tcp::acceptor acceptor;
 typedef boost::shared_ptr<boost::asio::ip::tcp::socket> sock_pt;

public:
 Server(boost::asio::io_service& io) : ios(io),
  acceptor(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 6688))
 {
  Start();
 }
 ~Server()
 {

 }

 void Start()
 {
  sock_pt sock(new boost::asio::ip::tcp::socket(ios)); // 智能指针

  // 异步侦听服务
  acceptor.async_accept(*sock, boost::bind(&Server::acceptor_handle,
             this, boost::asio::placeholders::error, sock));
 }

 void acceptor_handle(const boost::system::error_code& error, sock_pt sock)
 {
  if (error)
  {
   return;
  }
   cout << "client : ";

  // 输出连接的客户端信息
   cout << sock->remote_endpoint().address() << endl;

  //
   sock->async_write_some( boost::asio::buffer("hello asio"),
         boost::bind(&Server::write_handle,
         this, boost::asio::placeholders::error));

  Start(); // 再次启动异步接受连接
 }

 void write_handle(const boost::system::error_code& error)
 {
  cout << "send message is complate" << endl;
 }

};

int _tmain(int argc, _TCHAR* argv[])
{
 try
 {
  cout << "server start." << endl;

  boost::asio::io_service ios;

  Server serv(ios);

  ios.run();
 }
 catch (std::exception& e)
 {
  cout << e.what() << endl;
 }

 return 0;
}

首先检查asio传递的error_code，保证没有错误发生。然后调用socket对象的async_write_some()异步发送数据。同样，我们必须再为这个异步调用编写回调函数write_handler()。当发送完数据后不要忘记调用Start()再次启动服务器接受链接，否则当完成数据发送后io_service将因为没有时间处理而结束运行。

 

发送数据的回调函数write_handler()很简单，因为不需要做更多的工作，可以直接实现一个空函数，在这里简单地输出一条信息，表示异步发送数据完成

 

客户端：

[cpp]
// client.cpp : 定义控制台应用程序的入口点。  
//  
 
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "iostream"  
using namespace std; 
#include "vector"  
 
 
class Client 
{ 
private: 
    boost::asio::io_service& ios; 
    boost::asio::ip::tcp::endpoint ep;  // tcp端点  
    typedef boost::shared_ptr<boost::asio::ip::tcp::socket> sock_pt; 
 
public: 
    Client(boost::asio::io_service& io) : ios(io), 
        ep(boost::asio::ip::address::from_string("127.0.0.1"), 6688) 
    { 
        Start(); // 启动异步连接  
    } 
 
    ~Client() 
    { 
 
    } 
 
    void Start() 
    { 
        sock_pt sock(new boost::asio::ip::tcp::socket(ios)); 
        sock->async_connect(ep, boost::bind(&Client::conn_handle, this, 
                                            boost::asio::placeholders::error, sock)); 
    } 
 
    void conn_handle(const boost::system::error_code& error, sock_pt sock) 
    { 
        if (error) 
        { 
            return; 
        } 
        cout << "recive from : " << sock->remote_endpoint().address(); 
 
        // 建立接收数据的缓冲区  
        boost::shared_ptr<vector<char> > str(new vector<char>(100, 0)); 
 
        // 异步读取数据  
        sock->async_read_some(boost::asio::buffer(*str), boost::bind(&Client::read_handle, 
                                                                    this,  
                                                                    boost::asio::placeholders::error, 
                                                                    str)); 
        Start(); // 再次启动异步连接  
    } 
 
    void read_handle(const boost::system::error_code& error,  
                     boost::shared_ptr<vector<char> > str) 
    { 
        if (error) 
        { 
            return; 
        } 
        cout << &(*str)[0] << endl; 
    } 
}; 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    try 
    { 
        cout << "client start." << endl; 
        boost::asio::io_service ios; 
 
        Client client(ios); 
 
        ios.run(); 
    } 
    catch (std::exception& e) 
    { 
        cout << e.what() << endl; 
    } 
 
    return 0; 
} 

// client.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "iostream"
using namespace std;
#include "vector"

class Client
{
private:
 boost::asio::io_service& ios;
 boost::asio::ip::tcp::endpoint ep; // tcp端点
 typedef boost::shared_ptr<boost::asio::ip::tcp::socket> sock_pt;

public:
 Client(boost::asio::io_service& io) : ios(io),
  ep(boost::asio::ip::address::from_string("127.0.0.1"), 6688)
 {
  Start(); // 启动异步连接
 }

 ~Client()
 {

 }

 void Start()
 {
  sock_pt sock(new boost::asio::ip::tcp::socket(ios));
  sock->async_connect(ep, boost::bind(&Client::conn_handle, this,
           boost::asio::placeholders::error, sock));
 }

 void conn_handle(const boost::system::error_code& error, sock_pt sock)
 {
  if (error)
  {
   return;
  }
  cout << "recive from : " << sock->remote_endpoint().address();

  // 建立接收数据的缓冲区
  boost::shared_ptr<vector<char> > str(new vector<char>(100, 0));

  // 异步读取数据
  sock->async_read_some(boost::asio::buffer(*str), boost::bind(&Client::read_handle,
                 this,
                 boost::asio::placeholders::error,
                 str));
  Start(); // 再次启动异步连接
 }

 void read_handle(const boost::system::error_code& error,
      boost::shared_ptr<vector<char> > str)
 {
  if (error)
  {
   return;
  }
  cout << &(*str)[0] << endl;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 try
 {
  cout << "client start." << endl;
  boost::asio::io_service ios;

  Client client(ios);

  ios.run();
 }
 catch (std::exception& e)
 {
  cout << e.what() << endl;
 }

 return 0;
}

 

 

4、查询网络地址
之前关于tcp通信的所有论述都是使用直接的ip地址，但在实际生活中大多数时候，都不大可能知道socket链接另一端的地址，而只有一个域名，这时候我们就需要使用resolver类来通过域名获得可用的ip，它可以实现与ip版本无关的网址解析

 

resolver使用内部类query和iterator共同完成查询ip地址的工作：首先使用网址和服务名创建query对象，然后由resolve()函数生成iterator对象，它代表了查询到的ip端点。之后就可以使用socket对象尝试连接，知道找到一个可用的为止。

[cpp]
#include "stdafx.h"  
#include "boost/asio.hpp"  
#include "boost/date_time/posix_time/posix_time.hpp"  
#include "boost/bind.hpp"  
#include "boost/function.hpp"  
#include "boost/lexical_cast.hpp"  
#include "boost/asio/error.hpp"  
#include "iostream"  
using namespace std; 
 
 
void resolv_connect(boost::asio::ip::tcp::socket& sock, const char* name, int port) 
{ 
    boost::asio::ip::tcp::resolver rlv(sock.get_io_service()); 
    boost::asio::ip::tcp::resolver::query qry(name, boost::lexical_cast<string>(port)); 
 
    boost::asio::ip::tcp::resolver::iterator iter = rlv.resolve(qry); 
    boost::asio::ip::tcp::resolver::iterator end; 
 
    boost::system::error_code ec = boost::asio::error::host_not_found; 
    for (; ec && iter != end; ++iter) 
    { 
        sock.close(); 
        sock.connect(*iter, ec); 
    } 
 
    if (ec) 
    { 
        cout << "can't connect." << endl; 
        throw boost::system::error_code(ec); 
    } 
 
    cout << "connet suceessd." << endl; 
} 
 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    try 
    { 
        boost::asio::io_service ios; 
        boost::asio::ip::tcp::socket sock(ios); 
 
        resolv_connect(sock, "www.boost.org", 80); 
 
        ios.run(); 
    } 
    catch (std::exception& e) 
    { 
        cout << e.what() << endl; 
    } 
     
    return 0; 
} 

#include "stdafx.h"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/lexical_cast.hpp"
#include "boost/asio/error.hpp"
#include "iostream"
using namespace std;

void resolv_connect(boost::asio::ip::tcp::socket& sock, const char* name, int port)
{
 boost::asio::ip::tcp::resolver rlv(sock.get_io_service());
 boost::asio::ip::tcp::resolver::query qry(name, boost::lexical_cast<string>(port));

 boost::asio::ip::tcp::resolver::iterator iter = rlv.resolve(qry);
 boost::asio::ip::tcp::resolver::iterator end;

 boost::system::error_code ec = boost::asio::error::host_not_found;
 for (; ec && iter != end; ++iter)
 {
  sock.close();
  sock.connect(*iter, ec);
 }

 if (ec)
 {
  cout << "can't connect." << endl;
  throw boost::system::error_code(ec);
 }

 cout << "connet suceessd." << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
 try
 {
  boost::asio::io_service ios;
  boost::asio::ip::tcp::socket sock(ios);

  resolv_connect(sock, "www.boost.org", 80);

  ios.run();
 }
 catch (std::exception& e)
 {
  cout << e.what() << endl;
 }
 
 return 0;
}

resolv_connect()函数中使用lexical_cast，这是因为query对象只接受字符串参数，所以我们需要把端口号由整数转换为字符串。

 

当开始resolver的迭代时，需要使用error_code和逾尾迭代器两个条件来控制循环，因为有可能迭代完所有解析到的端点都无法连接，只有当error_code为0才表示连接成功。

 

有了resolv_connect()函数，就可以不受具体ip地址值的限制，以更直观更灵活的域名来连接服务器。