Chinese (Simplified Han script) (Boost Json Translation - en to zh_Hans translation catalogue (48 entries)

en: = Value Conversion While the <<ref_value>> container makes it easy to create ad-hoc structures, often it is necessary to convert between JSON and user-defined types or types from the standard library.
zh_Hans: = 值转换 尽管 &lt;<ref_value>&gt; 容器便于创建临时结构，但通常仍需在 JSON 与用户自定义类型或标准库类型之间进行转换。</ref_value>

en: The function template <<ref_value_from>> provides an interface to construct a <<ref_value>> from a type `T`. The function template <<ref_value_to>> converts in the opposite direction, from a type `T` to <<ref_value>>. Both support a wide variety of different https://en.cppreference.com/w/cpp/language/types[fundamental types], such as `int` or `double`, standard library types, such as `std::string` or `std::vector<T>`, and can be extended to support user-defined types.
zh_Hans: 函数模板 &lt;<ref_value_from>&gt; 提供了从类型 `T` 构造 &lt;<ref_value>&gt; 的接口。函数模板 &lt;<ref_value_to>&gt; 则执行相反方向的转换，从类型 `T` 转换为 &lt;<ref_value>&gt;。两者均支持多种不同的 https://en.cppreference.com/w/cpp/language/types[基础类型]（如 `int` 或 `double`）、标准库类型（如 `std::string` 或 `std::vector<t>`），并可扩展以支持用户定义类型。</t></ref_value></ref_value_to></ref_value></ref_value_from>

en: For the type `T`, the appropriate conversion approach is chosen from the following list of categories. The first matching category is selected.
zh_Hans: 对于类型 `T`，将从以下类别列表中选择合适的转换方式，并采用第一个匹配的类别。

en: Custom conversion.
zh_Hans: 自定义行为。

[ctx: :36]
en: Custom behavior.
zh_Hans: 自定义行为。

en: Boost.JSON container.
zh_Hans: Boost.JSON 容器

[ctx: :36]
en: The result is equal to the input value.
zh_Hans: 结果等于输入值。

en: `bool`
zh_Hans: 结果等于输入值。

en: a| The result is a number equal to input and has the type
zh_Hans: a| 结果是一个与输入值相等的数字，并且其类型为

en: `std::int64_t`, if `T` is a signed integer'; or
zh_Hans: 若 `T` 为有符号整数，则为 `std::int64_t`；或

en: `std::uint64_t`, if `T` is an unsigned integer; or
zh_Hans: 若 `T` 为无符号整数，则为 `std::uint64_t`；或

en: `double` otherwise.
zh_Hans: 否则为 `double`。

en: The result is created via <<ref_value_to_number>>.
zh_Hans: 结果通过 &lt;<ref_value_to_number>&gt; 创建。</ref_value_to_number>

en: Type satisfying <<ref_is_null_like>>
zh_Hans: 满足 &lt;<ref_is_null_like>&gt; 的类型</ref_is_null_like>

en: Intended for types like {std_monostate}.
zh_Hans: 适用于类似 {std_monostate} 的类型。

en: The result is a null value.
zh_Hans: 结果为空值。

en: The result is default-constructed.
zh_Hans: 结果将被默认构造。

en: Type satisfying <<ref_is_string_like>>.
zh_Hans: 满足 &lt;<ref_is_string_like>&gt; 的类型。</ref_is_string_like>

en: A sequence of `char`s, e.g. `std::string`.
zh_Hans: `char` 序列，例如 `std::string`。

en: The result is a <<ref_string>>.
zh_Hans: 结果为 &lt;<ref_string>&gt;。</ref_string>

en: The result is constructed from a <<ref_string_view>>.
zh_Hans: 结果由 &lt;<ref_string_view>&gt; 构造。</ref_string_view>

en: Type satisfying <<ref_is_variant_like>>.
zh_Hans: 满足 &lt;<ref_is_variant_like>&gt; 的类型。</ref_is_variant_like>

en: `std::variant` and similar types, e.g. `boost::variant2::variant`.
zh_Hans: `std::variant` 及类似类型，例如 `boost::variant2::variant`。

en: The result is equal to the result of conversion of the active variant
zh_Hans: 结果等同于对活跃的变体备选项进行转换所得的结果。

en: alternative. |The result holds the first alternative for which a conversion succeeds.
zh_Hans: a| 结果为一个数值，等于输入值且类型为：

en: Type satisfying <<ref_is_optional_like>>
zh_Hans: Type satisfying &lt;<ref_is_optional_like>&gt;</ref_is_optional_like>

en: If the input value is empty, the result is a `null`. Otherwise it is
zh_Hans: 若输入值为空，则结果为 `null`；否则该结果

en: equivalent to conversion of the object stored inside of optional. |The result is default constructed if the input value is `null`. Otherwise the result is constructed from the result of conversion of the input to the type stored in optional.
zh_Hans: 等同于将存储在可选对象内部的对象进行转换。| 如果输入值为 `null` ，则结果将默认进行构造。否则，结果将根据将输入转换为存储在可选对象中的类型所得到的结果进行构造。

en: Type satisfying <<ref_is_map_like>>.
zh_Hans: Type satisfying &lt;<ref_is_map_like>&gt;.</ref_is_map_like>

en: The result is an <<ref_object>>.
zh_Hans: The result is an &lt;<ref_object>&gt;.</ref_object>

en: Type satisfying <<ref_is_sequence_like>>.
zh_Hans: Type satisfying &lt;<ref_is_sequence_like>&gt;.</ref_is_sequence_like>

[ctx: :87]
en: The result is an <<ref_array>>.
zh_Hans: 结果是一个 &lt;<ref_array>&gt;。</ref_array>

en: Type satisfying <<ref_is_tuple_like>>.
zh_Hans: 满足 &lt;<ref_is_tuple_like>&gt; 的类型。</ref_is_tuple_like>

en: A heterogenous sequence with fixed size, e.g. `std::tuple` and `std::pair`.
zh_Hans: 一种具有固定大小的异构序列，例如 `std::tuple` 和 `std::pair`。

en: The result is constructed with the array elements as constructor arguments.
zh_Hans: 结果通过将数组元素作为构造函数参数进行构造。

en: Type satisfying <<ref_is_described_class>>
zh_Hans: 满足 &lt;<ref_is_described_class>&gt; 的类型。</ref_is_described_class>

en: The result is an <<ref_object>> with described members' names as keys.
zh_Hans: 结果是一个 &lt;<ref_object>&gt;，其键为描述性成员的名称。</ref_object>

en: The result is default-constructed and described members are assigned
zh_Hans: 结果将被默认构造，并为其所描述的成员赋予相应的值。

en: corresponding values.
zh_Hans: 相应的值。

en: Type satisfying <<ref_is_described_enum>>
zh_Hans: 满足 &lt;<ref_is_described_enum>&gt; 的类型。</ref_is_described_enum>

en: If the input value is equal to one of the described enumerators, the result is
zh_Hans: 如果输入值等于某个已描述的枚举项，则结果为

en: a <<ref_string>>, containing its name. Otherwise it's equal to the input value converted to its underlying type. |The result is the described enumerator, corresponding to the input <<ref_string>>.
zh_Hans: 一个包含该枚举项名称的 &lt;<ref_string>&gt;；否则，结果等同于将输入值转换为其底层类型后的值。</ref_string>

en: Type satisfying <<ref_is_path_like>>.
zh_Hans: 满足 &lt;<ref_is_path_like>&gt; 的类型。</ref_is_path_like>

en: `std::filesystem::path` and similar types, e.g. `boost::filesystem::path`.
zh_Hans: `std::filesystem::path` 及类似类型，例如 `boost::filesystem::path`。

en: The result is equal to the result of `path::generic_string`.
zh_Hans: 结果等于 `path::generic_string` 的结果。

en: The result is constructed from two pointers to `const char`.
zh_Hans: 结果由两个指向 `const char` 的指针构造而成。

en: For composite types (sequences, tuples, described classes, etc.) conversion of contained objects is applied recursively. For example:
zh_Hans: 对于复合类型（如序列、元组、已描述的类等），对其所包含对象的转换会递归应用。例如：

en: Here, the map is converted into an <<ref_object>>, since it matches <<ref_is_map_like>>. Each of its keys is converted into a <<ref_string>>, as `std::string` matches <<ref_is_string_like>>, and each of its values is converted into an <<ref_array>>, as `std::pair` matches <<ref_is_tuple_like>>. Finally, elements of pairs are converted into a `std::int64_t` number and a `bool`.
zh_Hans: 在这里，该地图会被转换为一个 &lt;<ref_object>&gt;，因为其符合 &lt;<ref_is_map_like>&gt; 这个条件。其每个键都会被转换为一个 &lt;<ref_string>&gt;，因为 `std::string` 符合 &lt;<ref_is_string_like>&gt; 这个条件，而其每个值都会被转换为一个 &lt;<ref_array>&gt;，因为 `std::pair` 符合 &lt;<ref_is_tuple_like>&gt; 这个条件。最后，对每个 `std::pair` 的元素进行转换，将其转换为一个 `std::int64_t` 数字和一个 `bool` 值。</ref_is_tuple_like></ref_array></ref_is_string_like></ref_string></ref_is_map_like></ref_object>
