Boost.Asio深入教程：异步网络编程基础

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

"Boost.Asio 是一个跨平台的C++库，用于网络和低级I/O编程，它为开发者提供了一种一致的异步模型，采用现代C++的方法。" Boost.Asio是C++开发中不可或缺的一个工具，尤其在处理网络通信和I/O操作时。该库由Christopher Kohlhoff创建并维护，自2003年起，Boost.Asio遵循Boost Software License 1.0发布，允许自由使用和分发。 **概述** Boost.Asio的核心特性包括对多种I/O操作的支持，如TCP和UDP网络通信，套接字操作，以及对定时器、信号量等事件驱动编程的支持。其设计目标是提供一种一致的异步编程模型，这使得开发者可以编写出高效的、可扩展的并发应用程序。库的设计基于C++11及更高版本的特性，强调代码的简洁性和可读性。 **使用Boost.Asio** 在你的应用中集成Boost.Asio时，首先需要了解其依赖项和所支持的平台。Boost.Asio通常与Boost库的其他部分一起使用，但也可以独立使用。它在大多数现代操作系统上都能运行，包括Windows、Linux、macOS等。 **教程** Boost.Asio的教程引导开发者了解基本概念，如异步操作、IO服务（IO Service）、工作线程（Work）和处理器（Handler）。教程还通过实例展示了如何构建简单的客户端和服务器程序，帮助初学者快速上手。 **示例** 为了进一步理解Boost.Asio的用法，库提供了各种示例，这些示例涵盖了更复杂的用例，如多线程服务器、并发客户端和高级网络协议实现。 **参考文档** 详细的类和函数参考提供了完整的API文档，对于深入理解和使用Boost.Asio至关重要。开发者可以在这里找到关于特定类、方法和对象的详细信息。 **修订历史** Boost.Asio的修订历史记录了在每个Boost发行版中所做的更改，这对于跟踪库的更新和改进很有帮助。 **索引** 如同一本技术书籍，Boost.Asio的文档还提供了书式文本索引，方便开发者快速查找所需信息。 Boost.Asio是一个强大且灵活的库，能够满足各种网络和I/O需求。无论是新手还是经验丰富的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页未读，继续阅读

ag128333

粉丝: 2
资源: 3

Boost.Asio深入教程：异步网络编程基础

C++ 之 Asio 库(全面解析)

Boost_asio权威傻瓜教程

boost_asio_参考手册

boost asio傻瓜教程

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

boost asio

boost.asio教程

Boost_asio傻瓜教程

Boost ASIO C++ 网络编程-带实例

boost_tutorial:一些有关如何使用boost asio网络库的演示

最新资源