Zen

Translation

type: paragraph
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
656/6560 · 656

Sign in to save translations.

English Chinese (Simplified Han script) Actions
Echo __example__
Echo __example__
This example develops an initiating function called [*echo]. The operation will read up to the first newline on a stream, and then write the same line including the newline back on the stream. First we define the input parameters and results, then declare our initiation function. For our echo operation the only inputs are the stream and the completion token. The output is the error code which is usually included in all completion handler signatures.
This example develops an initiating function called [*echo]. The operation will read up to the first newline on a stream, and then write the same line including the newline back on the stream. First we define the input parameters and results, then declare our initiation function. For our echo operation the only inputs are the stream and the completion token. The output is the error code which is usually included in all completion handler signatures.
Now that we have a declaration, we will define the body of the function. We want to achieve the following goals: perform static type checking on the input parameters, set up the return value as per __N3747__, and launch the composed operation by constructing an intermediate, stateful completion handler and invoking it.
Now that we have a declaration, we will define the body of the function. We want to achieve the following goals: perform static type checking on the input parameters, set up the return value as per __N3747__, and launch the composed operation by constructing an intermediate, stateful completion handler and invoking it.
The initiating function contains a few relatively simple parts. There is the customization of the return value type, static type checking, building the return value type using the helper, and creating and launching the `echo_op` composed operation object.
The initiating function contains a few relatively simple parts. There is the customization of the return value type, static type checking, building the return value type using the helper, and creating and launching the `echo_op` composed operation object.
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
There are some common mistakes that should be avoided when writing composed operations:
There are some common mistakes that should be avoided when writing composed operations:
* Type erasing the final handler. This will cause undefined behavior.
* Type erasing the final handler. This will cause undefined behavior.
* Forgetting to include a return statement after calling an
* Forgetting to include a return statement after calling an
* Calling a synchronous function by accident. In general composed
* Calling a synchronous function by accident. In general composed
* Forgetting to provide `executor_type` and `get_executor` for the
* Forgetting to provide `executor_type` and `get_executor` for the
* Forgetting to create an object of type __executor_work_guard__ with the
* Forgetting to create an object of type __executor_work_guard__ with the
* For operations which complete immediately (i.e. without calling an
* For operations which complete immediately (i.e. without calling an
The listing for a complete, runnable version of this example is in [path_link example/echo-op/echo_op.cpp echo_op.cpp].
The listing for a complete, runnable version of this example is in [path_link example/echo-op/echo_op.cpp echo_op.cpp].
English Chinese (Simplified Han script) Actions
Echo __example__
Echo __example__
This example develops an initiating function called [*echo]. The operation will read up to the first newline on a stream, and then write the same line including the newline back on the stream. First we define the input parameters and results, then declare our initiation function. For our echo operation the only inputs are the stream and the completion token. The output is the error code which is usually included in all completion handler signatures.
This example develops an initiating function called [*echo]. The operation will read up to the first newline on a stream, and then write the same line including the newline back on the stream. First we define the input parameters and results, then declare our initiation function. For our echo operation the only inputs are the stream and the completion token. The output is the error code which is usually included in all completion handler signatures.
Now that we have a declaration, we will define the body of the function. We want to achieve the following goals: perform static type checking on the input parameters, set up the return value as per __N3747__, and launch the composed operation by constructing an intermediate, stateful completion handler and invoking it.
Now that we have a declaration, we will define the body of the function. We want to achieve the following goals: perform static type checking on the input parameters, set up the return value as per __N3747__, and launch the composed operation by constructing an intermediate, stateful completion handler and invoking it.
The initiating function contains a few relatively simple parts. There is the customization of the return value type, static type checking, building the return value type using the helper, and creating and launching the `echo_op` composed operation object.
The initiating function contains a few relatively simple parts. There is the customization of the return value type, static type checking, building the return value type using the helper, and creating and launching the `echo_op` composed operation object.
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
There are some common mistakes that should be avoided when writing composed operations:
There are some common mistakes that should be avoided when writing composed operations:
* Type erasing the final handler. This will cause undefined behavior.
* Type erasing the final handler. This will cause undefined behavior.
* Forgetting to include a return statement after calling an
* Forgetting to include a return statement after calling an
* Calling a synchronous function by accident. In general composed
* Calling a synchronous function by accident. In general composed
* Forgetting to provide `executor_type` and `get_executor` for the
* Forgetting to provide `executor_type` and `get_executor` for the
* Forgetting to create an object of type __executor_work_guard__ with the
* Forgetting to create an object of type __executor_work_guard__ with the
* For operations which complete immediately (i.e. without calling an
* For operations which complete immediately (i.e. without calling an
The listing for a complete, runnable version of this example is in [path_link example/echo-op/echo_op.cpp echo_op.cpp].
The listing for a complete, runnable version of this example is in [path_link example/echo-op/echo_op.cpp echo_op.cpp].

Loading…

User avatar admin

String added in the repository
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
The implementation strategy is to make the composed object meet the requirements of a completion handler by being movable, and by making it invocable so it can be used as a continuation for the asynchronous operations it launches. Rather than using `std::bind` or `boost::bind`, which destroys the type information and therefore breaks the associators, we will simply pass `std::move(*this)` as the completion handler parameter for any operations that we initiate. For the move to work correctly, care must be taken to ensure that no access to data members are made after the move takes place. Here is the complete implementation of our composed operation:
06/05/2026
Browse all string changes

Things to check

Unchanged translation

Source and translation are identical.

Reset

Glossary

English Chinese (Simplified Han script)
No related strings found in the glossary.

String information

Source string description
type: paragraph
Unit identifier
59538
Source string location
string ID 33
String age
06/05/2026
Last updated
06/05/2026
Source string age
06/05/2026
Translation file QuickBook file
doc/qbk/03_core/7a_echo_zh_Hans.qbk, string 5