Boost.Asio库编程指南

4星 · 超过85%的资源需积分: 14 5 浏览量更新于2024-07-23 收藏 12.16MB PDF 举报

"《Boost.Asio库编程》是Christopher Kohlhoff编写的关于使用Boost.Asio库进行网络和低级I/O编程的指南。该库遵循Boost Software License 1.0版，提供了一种跨平台、现代C++的异步编程模型。" Boost.Asio库是一个关键的C++库，它在开发人员中广受欢迎，因为其功能强大且易于使用。这个库的核心在于它提供了对网络通信和低级I/O操作的一致异步处理，使得开发者能够构建高性能的并发服务器和客户端应用程序。 **概述** Boost.Asio的特性包括但不限于： 1. **异步I/O** - 它允许开发者编写非阻塞的代码，提高了程序的并发性和效率。 2. **多种协议支持** - 支持TCP/UDP等网络协议，以及套接字、信号量、本地域连接等多种I/O操作。 3. **跨平台兼容性** - Boost.Asio可以在多个操作系统上运行，如Windows、Linux、macOS等。 4. **现代C++设计** - 库的设计充分利用了C++的特性，如模板、RAII（Resource Acquisition Is Initialization）和智能指针，以提高代码的可读性和安全性。 **使用Boost.Asio** 要将Boost.Asio集成到你的应用中，你需要了解以下几点： 1. **依赖项** - Boost.Asio通常需要Boost库的一部分作为依赖，确保正确安装和链接。 2. **平台支持** - 检查你的开发环境是否在Boost.Asio的官方支持列表中。 3. **错误处理** - Boost.Asio提供了异常处理机制，需要理解如何有效地捕获和处理错误。 **教程** 对于初学者，教程会引导你了解基本概念，例如： 1. **异步操作** - 如何启动一个异步操作，然后在一个回调函数中处理结果。 2. **服务与工作线程** - 理解如何使用服务执行器和工作对象来管理异步任务的执行。 3. **客户端和服务器示例** - 创建简单的TCP或UDP客户端和服务器，演示如何建立连接、发送和接收数据。 **例子** 更复杂的应用示例可以帮助你学习如何处理特定场景，如： 1. **多线程编程** - 使用Boost.Asio实现线程安全的并发。 2. **SSL/TLS加密** - 集成SSL/TLS支持以实现安全的网络通信。 3. **时间轮定时器** - 利用Boost.Asio的定时器系统进行定时任务调度。 **参考文档** 详细的类和函数参考提供了深入的技术细节，帮助你查找特定API的使用方法和参数说明。 **修订历史** 记录了Boost.Asio在每个Boost版本中的更新和改进，这对于跟踪库的发展和解决问题非常有用。通过学习和掌握Boost.Asio库，你可以构建出高效、可靠的网络应用，无论是简单的通信服务还是复杂的分布式系统。它为C++开发者提供了一把强大的工具，使得网络编程变得更加简单和高效。

class match_char

{

public:

explicit match_char(char c) : c_(c) {}

template <typename Iterator>

std::pair<Iterator, bool> operator()(

Iterator begin, Iterator end) const

{

Iterator i = begin;

while (i != end)

if (c_ == *i++)

return std::make_pair(i, true);

return std::make_pair(i, false);

}

private:

char c_;

};

namespace boost { namespace asio {

template <> struct is_match_condition<match_char>

: public boost::true_type {};

} } // namespace boost::asio

...

boost::asio::streambuf b;

boost::asio::read_until(s, b, match_char('a'));

The is_match_condition<> type trait automatically evaluates to true for functions, and for function objects with a nested res-

ult_type typedef. For other types the trait must be explicitly specialised, as shown above.

See Also

async_read_until(), is_match_condition, read_until(), streambuf, HTTP client example.

Custom Memory Allocation

Many asynchronous operations need to allocate an object to store state associated with the operation. For example, a Win32 imple-

mentation needs OVERLAPPED-derived objects to pass to Win32 API functions.

Furthermore, programs typically contain easily identiﬁable chains of asynchronous operations. A half duplex protocol implementation

(e.g. an HTTP server) would have a single chain of operations per client (receives followed by sends). A full duplex protocol imple-

mentation would have two chains executing in parallel. Programs should be able to leverage this knowledge to reuse memory for

all asynchronous operations in a chain.

Given a copy of a user-deﬁned Handler object h, if the implementation needs to allocate memory associated with that handler it

will execute the code:

void* pointer = asio_handler_allocate(size, &h);

Similarly, to deallocate the memory it will execute:

asio_handler_deallocate(pointer, size, &h);

These functions are located using argument-dependent lookup. The implementation provides default implementations of the above

functions in the asio namespace:

Boost.Asio

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

void* asio_handler_allocate(size_t, ...);

void asio_handler_deallocate(void*, size_t, ...);

which are implemented in terms of ::operator new() and ::operator delete() respectively.

The implementation guarantees that the deallocation will occur before the associated handler is invoked, which means the memory

is ready to be reused for any new asynchronous operations started by the handler.

The custom memory allocation functions may be called from any user-created thread that is calling a library function. The imple-

mentation guarantees that, for the asynchronous operations included the library, the implementation will not make concurrent calls

to the memory allocation functions for that handler. The implementation will insert appropriate memory barriers to ensure correct

memory visibility should allocation functions need to be called from different threads.

See Also

asio_handler_allocate, asio_handler_deallocate, custom memory allocation example.

Handler Tracking

To aid in debugging asynchronous programs, Boost.Asio provides support for handler tracking. When enabled by deﬁning

BOOST_ASIO_ENABLE_HANDLER_TRACKING, Boost.Asio writes debugging output to the standard error stream. The output records

asynchronous operations and the relationships between their handlers.

This feature is useful when debugging and you need to know how your asynchronous operations are chained together, or what the

pending asynchronous operations are. As an illustration, here is the output when you run the HTTP Server example, handle a single

request, then shut down via Ctrl+C:

@asio|1298160085.070638|0*1|signal_set@0x7fff50528f40.async_wait

@asio|1298160085.070888|0*2|socket@0x7fff50528f60.async_accept

@asio|1298160085.070913|0|resolver@0x7fff50528e28.cancel

@asio|1298160118.075438|>2|ec=asio.system:0

@asio|1298160118.075472|2*3|socket@0xb39048.async_receive

@asio|1298160118.075507|2*4|socket@0x7fff50528f60.async_accept

@asio|1298160118.075527|<2|

@asio|1298160118.075540|>3|ec=asio.system:0,bytes_transferred=122

@asio|1298160118.075731|3*5|socket@0xb39048.async_send

@asio|1298160118.075778|<3|

@asio|1298160118.075793|>5|ec=asio.system:0,bytes_transferred=156

@asio|1298160118.075831|5|socket@0xb39048.close

@asio|1298160118.075855|<5|

@asio|1298160122.827317|>1|ec=asio.system:0,signal_number=2

@asio|1298160122.827333|1|socket@0x7fff50528f60.close

@asio|1298160122.827359|<1|

@asio|1298160122.827370|>4|ec=asio.system:125

@asio|1298160122.827378|<4|

@asio|1298160122.827394|0|signal_set@0x7fff50528f40.cancel

Each line is of the form:

The <tag> is always @asio, and is used to identify and extract the handler tracking messages from the program output.

The <timestamp> is seconds and microseconds from 1 Jan 1970 UTC.

The <action> takes one of the following forms:

>n The program entered the handler number n. The <description> shows the arguments to the handler.

Boost.Asio

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

<n The program left handler number n.

!n The program left handler number n due to an exception.

~n The handler number n was destroyed without having been invoked. This is usually the case for any unﬁnished asynchronous

operations when the io_service is destroyed.

n*m The handler number n created a new asynchronous operation with completion handler number m. The <description> shows

what asynchronous operation was started.

n The handler number n performed some other operation. The <description> shows what function was called. Currently

only close() and cancel() operations are logged, as these may affect the state of pending asynchronous operations.

Where the <description> shows a synchronous or asynchronous operation, the format is <object-type>@<pointer>.<oper-

ation>. For handler entry, it shows a comma-separated list of arguments and their values.

As shown above, Each handler is assigned a numeric identiﬁer. Where the handler tracking output shows a handler number of 0, it

means that the action was performed outside of any handler.

Visual Representations

The handler tracking output may be post-processed using the included handlerviz.pl tool to create a visual representation of the

handlers (requires the GraphViz tool dot).

Networking

• TCP, UDP and ICMP

• Socket Iostreams

• The BSD Socket API and Boost.Asio

TCP, UDP and ICMP

Boost.Asio provides off-the-shelf support for the internet protocols TCP, UDP and ICMP.

TCP Clients

Hostname resolution is performed using a resolver, where host and service names are looked up and converted into one or more en-

dpoints:

ip::tcp::resolver resolver(my_io_service);

ip::tcp::resolver::query query("www.boost.org", "http");

ip::tcp::resolver::iterator iter = resolver.resolve(query);

ip::tcp::resolver::iterator end; // End marker.

while (iter != end)

{

ip::tcp::endpoint endpoint = *iter++;

std::cout << endpoint << std::endl;

}

The list of endpoints obtained above could contain both IPv4 and IPv6 endpoints, so a program should try each of them until it ﬁnds

one that works. This keeps the client program independent of a speciﬁc IP version.

To simplify the development of protocol-independent programs, TCP clients may establish connections using the free functions

connect() and async_connect(). These operations try each endpoint in a list until the socket is successfully connected. For example,

a single call:

Boost.Asio

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

剩余1273页未读，继续阅读

gaoyuyihao

粉丝: 50
资源: 256

Boost.Asio库编程指南

boost asio编程

Boost asio 网络编程中文版

boost::asio写的文件上传下载程序

Boost.Asio C++ Network Programming_Network_C++_ASIO_boost.asio_B

boost_pdf_1_43.zip

boost.asio 代码 侯捷_-_Boost_技术与应用.pdf

Boost.Asio C++ 网络编程.pdf

Boost.Asio.C++.Network.Programming

boost-asio-cpp-network-programming.zip_BOOST教程_Boost_boost asio

Boost.Asio-20200124.pdf

最新资源

boost.asio 代码侯捷_-_Boost_技术与应用.pdf