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	Category of T

en	Comment

en	`value_from` behavior

en	`value_to` behavior

en	Custom conversion.
zh-hans	自定义行为。

en	Custom behavior.
zh-hans	自定义行为。

en	Boost.JSON container.
zh-hans	Boost.JSON 容器

en	The result is equal to the input value.
zh-hans	结果等于输入值。

en	`bool`
zh-hans	结果等于输入值。

en	https://en.cppreference.com/w/cpp/types/is_arithmetic[Arithmetic type]

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	A one-to-one mapping (e.g. `std::map`) with string-like keys.

en	The result is an <<ref_object>>.
zh-hans	The result is an &lt;<ref_object>&gt;.</ref_object>

en	The result is default-constructed, and elements are `insert`-ed at the end.

en	Type satisfying <<ref_is_sequence_like>>.
zh-hans	Type satisfying &lt;<ref_is_sequence_like>&gt;.</ref_is_sequence_like>

en	A sequence of elements, e.g. `std::vector`.

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>

en	:leveloffset: +1

en	include::custom.adoc[] include::nothrow.adoc[] include::alloc.adoc[] include::context.adoc[] include::forward.adoc[] include::direct.adoc[] include::guidelines.adoc[]

en	:leveloffset: -1