自学教程：C++ ASIO_MOVE_CAST函数代码示例

 read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,     CompletionCondition completion_condition, ReadHandler& handler)   : detail::base_from_completion_cond<       CompletionCondition>(completion_condition),     stream_(stream),     buffers_(buffers),     start_(0),     total_transferred_(0),     handler_(ASIO_MOVE_CAST(ReadHandler)(handler)) { }

 win_iocp_socket_recvmsg_op(     socket_ops::weak_cancel_token_type cancel_token,     const MutableBufferSequence& buffers,     socket_base::message_flags& out_flags, Handler& handler)   : operation(&win_iocp_socket_recvmsg_op::do_complete),     cancel_token_(cancel_token),     buffers_(buffers),     out_flags_(out_flags),     handler_(ASIO_MOVE_CAST(Handler)(handler)) { }

 connect_op(basic_socket<Protocol, SocketService>& sock,            const Iterator& begin, const Iterator& end,            const ConnectCondition& connect_condition,            ComposedConnectHandler& handler)     : base_from_connect_condition<ConnectCondition>(connect_condition),       socket_(sock),       iter_(begin),       end_(end),       start_(0),       handler_(ASIO_MOVE_CAST(ComposedConnectHandler)(handler)) { }

 read_op(AsyncReadStream& stream,     const asio::mutable_buffers_1& buffers,     CompletionCondition completion_condition,     ReadHandler& handler)   : detail::base_from_completion_cond<       CompletionCondition>(completion_condition),     stream_(stream),     buffer_(buffers),     total_transferred_(0),     handler_(ASIO_MOVE_CAST(ReadHandler)(handler)) { }

 read_at_op(AsyncRandomAccessReadDevice& device,     boost::uint64_t offset, const asio::mutable_buffers_1& buffers,     CompletionCondition completion_condition, ReadHandler& handler)   : detail::base_from_completion_cond<       CompletionCondition>(completion_condition),     device_(device),     offset_(offset),     buffer_(buffers),     total_transferred_(0),     handler_(ASIO_MOVE_CAST(ReadHandler)(handler)) { }

 win_iocp_socket_recvfrom_op(Endpoint& endpoint,     socket_ops::weak_cancel_token_type cancel_token,     const MutableBufferSequence& buffers, Handler& handler)   : operation(&win_iocp_socket_recvfrom_op::do_complete),     endpoint_(endpoint),     endpoint_size_(static_cast<int>(endpoint.capacity())),     cancel_token_(cancel_token),     buffers_(buffers),     handler_(ASIO_MOVE_CAST(Handler)(handler)) {   handler_work<Handler>::start(handler_); }

 write_at_op(AsyncRandomAccessWriteDevice& device,     boost::uint64_t offset, const ConstBufferSequence& buffers,     CompletionCondition completion_condition, WriteHandler& handler)   : detail::base_from_completion_cond<       CompletionCondition>(completion_condition),     device_(device),     offset_(offset),     buffers_(buffers),     total_transferred_(0),     handler_(ASIO_MOVE_CAST(WriteHandler)(handler)) { }

 range_connect_op(basic_socket<Protocol ASIO_SVC_TARG>& sock,     const EndpointSequence& endpoints,     const ConnectCondition& connect_condition,     RangeConnectHandler& handler)   : base_from_connect_condition<ConnectCondition>(connect_condition),     socket_(sock),     endpoints_(endpoints),     index_(0),     start_(0),     handler_(ASIO_MOVE_CAST(RangeConnectHandler)(handler)) { }

 write_op(AsyncWriteStream& stream,     const asio::const_buffers_1& buffers,     CompletionCondition completion_condition,     WriteHandler& handler)   : detail::base_from_completion_cond<       CompletionCondition>(completion_condition),     stream_(stream),     buffer_(buffers),     total_transferred_(0),     handler_(ASIO_MOVE_CAST(WriteHandler)(handler)) { }

  async_accept(basic_socket<Protocol1, SocketService>& peer,      ASIO_MOVE_ARG(AcceptHandler) handler,      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)  {    // If you get an error on the following line it means that your handler does    // not meet the documented type requirements for a AcceptHandler.    ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;    return this->get_service().async_accept(this->get_implementation(),        peer, static_cast<endpoint_type*>(0),        ASIO_MOVE_CAST(AcceptHandler)(handler));  }

 iterator_connect_op(basic_socket<Protocol ASIO_SVC_TARG>& sock,     const Iterator& begin, const Iterator& end,     const ConnectCondition& connect_condition,     IteratorConnectHandler& handler)   : base_from_connect_condition<ConnectCondition>(connect_condition),     socket_(sock),     iter_(begin),     end_(end),     start_(0),     handler_(ASIO_MOVE_CAST(IteratorConnectHandler)(handler)) { }

 reactive_socket_recv_op( socket_type socket,                          socket_ops::state_type state,                          const MutableBufferSequence& buffers,                          socket_base::message_flags flags,                          Handler& handler )     : reactive_socket_recv_op_base<MutableBufferSequence>( socket,                                                            state,                                                            buffers,                                                            flags,                                                            &reactive_socket_recv_op::do_complete ),       handler_( ASIO_MOVE_CAST( Handler )( handler ) ) { }

 win_iocp_socket_recvmsg_op(     socket_ops::weak_cancel_token_type cancel_token,     const MutableBufferSequence& buffers,     socket_base::message_flags& out_flags,     Handler& handler, const IoExecutor& io_ex)   : operation(&win_iocp_socket_recvmsg_op::do_complete),     cancel_token_(cancel_token),     buffers_(buffers),     out_flags_(out_flags),     handler_(ASIO_MOVE_CAST(Handler)(handler)),     io_executor_(io_ex) {   handler_work<Handler, IoExecutor>::start(handler_, io_executor_); }

 win_iocp_socket_accept_op(win_iocp_socket_service_base& socket_service,     socket_type socket, Socket& peer, const Protocol& protocol,     typename Protocol::endpoint* peer_endpoint,     bool enable_connection_aborted, Handler& handler)   : operation(&win_iocp_socket_accept_op::do_complete),     socket_service_(socket_service),     socket_(socket),     peer_(peer),     protocol_(protocol),     peer_endpoint_(peer_endpoint),     enable_connection_aborted_(enable_connection_aborted),     handler_(ASIO_MOVE_CAST(Handler)(handler)) { }

 win_iocp_socket_move_accept_op(     win_iocp_socket_service_base& socket_service, socket_type socket,     const Protocol& protocol, asio::io_context& peer_io_context,     typename Protocol::endpoint* peer_endpoint,     bool enable_connection_aborted, Handler& handler)   : operation(&win_iocp_socket_move_accept_op::do_complete),     socket_service_(socket_service),     socket_(socket),     peer_(peer_io_context),     protocol_(protocol),     peer_endpoint_(peer_endpoint),     enable_connection_aborted_(enable_connection_aborted),     handler_(ASIO_MOVE_CAST(Handler)(handler)) {   handler_work<Handler>::start(handler_); }

    void operator()(asio::error_code ec, int start = 0)    {        switch (start_ = start)        {        case 1:            for (;;)            {                this->check_condition(ec, iter_, end_);                if (iter_ != end_)                {                    socket_.close(ec);                    socket_.async_connect(*iter_,                                          ASIO_MOVE_CAST(connect_op)(*this));                    return;                }                if (start)                {                    ec = asio::error::not_found;                    socket_.get_io_service().post(detail::bind_handler(*this, ec));                    return;                }            default:                if (iter_ == end_)                    break;                if (!socket_.is_open())                {                    ec = asio::error::operation_aborted;                    break;                }                if (!ec)                    break;                ++iter_;            }            handler_(static_cast<const asio::error_code&>(ec),                     static_cast<const Iterator&>(iter_));        }    }

    void operator()(const asio::error_code& ec,        std::size_t bytes_transferred, int start = 0)    {      switch (start)      {        case 1:        buffers_.prepare(this->check_for_completion(ec, total_transferred_));        for (;;)        {          device_.async_read_some_at(offset_ + total_transferred_,              buffers_, ASIO_MOVE_CAST(read_at_op)(*this));          return; default:          total_transferred_ += bytes_transferred;          buffers_.consume(bytes_transferred);          buffers_.prepare(this->check_for_completion(ec, total_transferred_));          if ((!ec && bytes_transferred == 0)              || buffers_.begin() == buffers_.end())            break;        }        handler_(ec, static_cast<const std::size_t&>(total_transferred_));      }    }

 completion_handler(Handler& h)   : operation(&completion_handler::do_complete),     handler_(ASIO_MOVE_CAST(Handler)(h)) { }

 winrt_socket_connect_op(Handler& handler)   : winrt_async_op<void>(&winrt_socket_connect_op::do_complete),     handler_(ASIO_MOVE_CAST(Handler)(handler)) {   handler_work<Handler>::start(handler_); }

 /**  * This constructor moves a handle from one object to another.  *  * @param other The other basic_handle object from which the move will occur.  *  * @note Following the move, the moved-from object is in the same state as if  * constructed using the @c basic_handle(io_service&) constructor.  */ basic_handle(basic_handle&& other)   : basic_io_object<HandleService>(       ASIO_MOVE_CAST(basic_handle)(other)) { }

 /**  * This assignment operator moves a handle from one object to another.  *  * @param other The other basic_handle object from which the move will occur.  *  * @note Following the move, the moved-from object is in the same state as if  * constructed using the @c basic_handle(io_service&) constructor.  */ basic_handle& operator=(basic_handle&& other) {   basic_io_object<HandleService>::operator=(       ASIO_MOVE_CAST(basic_handle)(other));   return *this; }

 signal_handler(Handler& h)   : signal_op(&signal_handler::do_complete),     handler_(ASIO_MOVE_CAST(Handler)(h)) { }

 /// Move constructor. basic_resolver_iterator(basic_resolver_iterator&& other)   : values_(ASIO_MOVE_CAST(values_ptr_type)(other.values_)),     index_(other.index_) {   other.index_ = 0; }

 work_dispatcher(work_dispatcher&& other)   : work_(ASIO_MOVE_CAST(executor_work_guard<       typename associated_executor<Handler>::type>)(other.work_)),     handler_(ASIO_MOVE_CAST(Handler)(other.handler_)) { }

 winrt_socket_send_op(const ConstBufferSequence& buffers, Handler& handler)   : winrt_async_op<unsigned int>(&winrt_socket_send_op::do_complete),     buffers_(buffers),     handler_(ASIO_MOVE_CAST(Handler)(handler)) { }

 buffered_fill_handler(buffered_fill_handler&& other)   : storage_(other.storage_),     previous_size_(other.previous_size_),     handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_)) { }

 win_iocp_overlapped_op(Handler& handler)   : operation(&win_iocp_overlapped_op::do_complete),     handler_(ASIO_MOVE_CAST(Handler)(handler)) {   handler_work<Handler>::start(handler_); }

  }  /// Start an asynchronous read. The buffer into which the data will be read  /// must be valid for the lifetime of the asynchronous operation.  template <typename MutableBufferSequence, typename ReadHandler>  ASIO_INITFN_RESULT_TYPE(ReadHandler,      void (asio::error_code, std::size_t))  async_read_some(const MutableBufferSequence& buffers,      ASIO_MOVE_ARG(ReadHandler) handler)  {    detail::async_result_init<      ReadHandler, void (asio::error_code, std::size_t)> init(        ASIO_MOVE_CAST(ReadHandler)(handler));    next_layer_.async_read_some(buffers,        ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(ReadHandler,            void (asio::error_code, std::size_t)))(init.handler));    return init.result.get();  }  /// Peek at the incoming data on the stream. Returns the number of bytes read.  /// Throws an exception on failure.  template <typename MutableBufferSequence>  std::size_t peek(const MutableBufferSequence& buffers)  {    return next_layer_.peek(buffers);  }  /// Peek at the incoming data on the stream. Returns the number of bytes read,  /// or 0 if an error occurred.  template <typename MutableBufferSequence>