Merge branch 'develop' into claude/fix-issue-2649-738aba

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Construct explicitly in get_to() and to_json(std::optional)
2026-09-30 11:40:30 +00:00 · 2026-09-27 20:58:11 +02:00 · 2026-09-27 18:31:22 +02:00 · 2026-09-27 16:32:26 +02:00
7 changed files with 228 additions and 309 deletions
@@ -272,6 +272,15 @@ basic_json(basic_json&& other) noexcept;
        When used without parentheses around an empty initializer list, `basic_json()` is called instead of this
        function, yielding the JSON `#!json null` value.

+- Overload 4:
+
+    !!! info "Implicit conversion"
+
+        The conversion is implicit unless [`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md)
+        is defined to `0` and `BasicJsonType::string_t` differs from `string_t`. In that case, the constructor is
+        `explicit`, so a JSON value with a different string type is no longer silently converted, for example when it is
+        passed to a function taking `#!cpp const json&`. Write `#!cpp json(other)` or `#!cpp other.get<json>()` instead.
+
 - Overload 7:

    !!! info "Preconditions"
@@ -420,7 +429,8 @@ basic_json(basic_json&& other) noexcept;
 1. Since version 1.0.0.
 2. Since version 1.0.0.
 3. Since version 2.1.0.
-4. Since version 3.2.0.
+4. Since version 3.2.0. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
+   version 3.13.0.
 5. Since version 1.0.0.
 6. Since version 1.0.0.
 7. Since version 1.0.0.
@@ -5,7 +5,9 @@
 ```

 When defined to `0`, implicit conversions are switched off. By default, implicit conversions are switched on. The
-value directly affects [`operator ValueType`](../basic_json/operator_ValueType.md).
+value directly affects [`operator ValueType`](../basic_json/operator_ValueType.md) and the
+[converting constructor](../basic_json/basic_json.md) from a `basic_json` specialization with a different string
+type (overload 4).

 ## Default definition

@@ -57,6 +59,25 @@ By default, implicit conversions are enabled.
    auto s = j.get<std::string>();
    ```

+??? example "Conversion between `basic_json` specializations"
+
+    A `basic_json` specialization with a different string type is also no longer converted implicitly when
+    `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`:
+
+    ```cpp
+    using wjson = nlohmann::basic_json<std::map, std::vector, std::wstring>;
+
+    void load(const nlohmann::json& j);
+
+    wjson wj = /* ... */;
+    load(wj);                            // error: no implicit conversion
+    load(nlohmann::json(wj));            // OK: explicit conversion
+    load(wj.get<nlohmann::json>());      // OK: explicit conversion
+    ```
+
+    Specializations that share the same string type, such as `json` and `ordered_json`, remain implicitly
+    convertible.
+
 ## See also

 - [**operator ValueType**](../basic_json/operator_ValueType.md) - get a value (implicit)
@@ -66,3 +87,4 @@ By default, implicit conversions are enabled.
 ## Version history

 - Added in version 3.9.0.
+- Also affects the conversion between `basic_json` specializations with different string types since version 3.13.0.
@@ -42,10 +42,6 @@ namespace detail
 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
 * allocated value (e.g., a string). See bug issue
 * https://github.com/nlohmann/json/issues/2865 for more information.
- *
- * A value that has to be allocated is created before the old one is destroyed:
- * were it the other way around, an exception while creating the new value would
- * leave j with the type of the new value, but the pointer to the destroyed old one.
 */

 template<value_t> struct external_constructor;
@@ -69,20 +65,18 @@ struct external_constructor<value_t::string>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
-        const typename BasicJsonType::json_value value(s);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = value;
+        j.m_data.m_value = s;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
    {
-        const typename BasicJsonType::json_value value(std::move(s));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = value;
+        j.m_data.m_value = std::move(s);
        j.assert_invariant();
    }

@@ -91,10 +85,9 @@ struct external_constructor<value_t::string>
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
-        auto* created = j.template create<typename BasicJsonType::string_t>(str);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value.string = created;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
        j.assert_invariant();
    }
 };
@@ -105,20 +98,18 @@ struct external_constructor<value_t::binary>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
    {
-        const typename BasicJsonType::json_value value(b);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = value;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
    {
-        const typename BasicJsonType::json_value value(std::move(b));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = value;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
        j.assert_invariant();
    }
 };
@@ -168,10 +159,9 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
    {
-        const typename BasicJsonType::json_value value(arr);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
+        j.m_data.m_value = arr;
        j.set_parents();
        j.assert_invariant();
    }
@@ -179,10 +169,9 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
    {
-        const typename BasicJsonType::json_value value(std::move(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
+        j.m_data.m_value = std::move(arr);
        j.set_parents();
        j.assert_invariant();
    }
@@ -198,10 +187,9 @@ struct external_constructor<value_t::array>
        using std::begin;
        using std::end;

-        auto* created = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value.array = created;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.set_parents();
        j.assert_invariant();
    }
@@ -209,17 +197,15 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
    {
-        typename BasicJsonType::array_t elements;
-        elements.reserve(arr.size());
-        for (const bool x : arr)
-        {
-            elements.push_back(x);
-        }
-        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
-        j.set_parents();
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
        j.assert_invariant();
    }

@@ -227,12 +213,11 @@ struct external_constructor<value_t::array>
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
    {
-        typename BasicJsonType::array_t elements(arr.size());
-        std::copy(std::begin(arr), std::end(arr), elements.begin());
-        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
        j.set_parents();
        j.assert_invariant();
    }
@@ -244,16 +229,14 @@ struct external_constructor<value_t::array>
             enable_if_t<is_compatible_range_view<std::remove_cvref_t<CompatibleArrayType>>::value, int> = 0>
    static void construct(BasicJsonType& j, CompatibleArrayType && arr)
    {
-        typename BasicJsonType::array_t elements;
-        for (auto&& x : std::forward<CompatibleArrayType>(arr))
-        {
-            elements.push_back(x);
-        }
-        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
-        j.set_parents();
+        j.m_data.m_value = value_t::array;
+        for (auto&& x : std::forward<CompatibleArrayType>(arr))
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
        j.assert_invariant();
    }
 #endif
@@ -265,10 +248,9 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
    {
-        const typename BasicJsonType::json_value value(obj);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = value;
+        j.m_data.m_value = obj;
        j.set_parents();
        j.assert_invariant();
    }
@@ -276,10 +258,9 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
    {
-        const typename BasicJsonType::json_value value(std::move(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = value;
+        j.m_data.m_value = std::move(obj);
        j.set_parents();
        j.assert_invariant();
    }
@@ -291,10 +272,9 @@ struct external_constructor<value_t::object>
        using std::begin;
        using std::end;

-        auto* created = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value.object = created;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.set_parents();
        j.assert_invariant();
    }
@@ -311,7 +291,9 @@ void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept
 {
    if (opt.has_value())
    {
-        j = *opt;
+        // explicit construction, as the conversion from a basic_json with a different
+        // string type is explicit if JSON_USE_IMPLICIT_CONVERSIONS is 0 (#2649)
+        j = BasicJsonType(*opt);
    }
    else
    {
@@ -1605,12 +1605,42 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        assert_invariant();
    }

+  private:
+    /// whether a basic_json specialization can be converted implicitly into this one;
+    /// with JSON_USE_IMPLICIT_CONVERSIONS set to 0, this is only the case if both share
+    /// the same string type (see https://github.com/nlohmann/json/issues/2649)
+    template<typename BasicJsonType>
+    using is_implicitly_convertible_basic_json = std::integral_constant < bool,
+          (JSON_USE_IMPLICIT_CONVERSIONS != 0)
+          || std::is_same<typename BasicJsonType::string_t, string_t>::value >;
+
+    /// tag to select the constructor that performs the conversion from another basic_json specialization
+    struct convert_basic_json_tag {};
+
+  public:
    /// @brief create a JSON value from an existing one
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    template < typename BasicJsonType,
               detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
+                   && is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
    basic_json(const BasicJsonType& val)
+        : basic_json(val, convert_basic_json_tag{})
+    {}
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
+                   && !is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
+    explicit basic_json(const BasicJsonType& val)
+        : basic_json(val, convert_basic_json_tag{})
+    {}
+
+  private:
+    template<typename BasicJsonType>
+    basic_json(const BasicJsonType& val, convert_basic_json_tag /*unused*/)
 #if JSON_DIAGNOSTIC_POSITIONS
        : start_position(val.start_pos()),
          end_position(val.end_pos())
@@ -1666,6 +1696,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        assert_invariant();
    }

+  public:
    /// @brief create a container (array or object) from an initializer list
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(initializer_list_t init,
@@ -1702,8 +1733,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        if (is_an_object)
        {
            // the initializer list is a list of pairs -> create an object
-            m_data.m_value = value_t::object;
            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;

            for (auto& element_ref : init)
            {
@@ -1725,8 +1756,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            }
 #endif
            // the initializer list describes an array -> create an array
-            m_data.m_value.array = create<array_t>(init.begin(), init.end());
            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
        }

        set_parents();
@@ -1739,8 +1770,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init)
    {
        auto res = basic_json();
-        res.m_data.m_value = init;
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
        return res;
    }

@@ -1750,8 +1781,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_value = binary_t(init, subtype);
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
        return res;
    }

@@ -1761,8 +1792,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init)
    {
        auto res = basic_json();
-        res.m_data.m_value = std::move(init);
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
        return res;
    }

@@ -1772,8 +1803,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_value = binary_t(std::move(init), subtype);
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
        return res;
    }

@@ -2432,7 +2463,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                   int > = 0 >
    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
    {
-        return *this;
+        return BasicJsonType(*this);
    }

    /*!
@@ -2571,7 +2602,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 int> = 0>
    ValueType & get_to(ValueType& v) const
    {
-        v = *this;
+        v = ValueType(*this);
        return v;
    }

@@ -2819,8 +2850,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty array
        if (is_null())
        {
-            m_data.m_value.array = create<array_t>();
            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
            assert_invariant();
        }

@@ -2879,8 +2910,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_value.object = create<object_t>();
            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

@@ -2932,8 +2963,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_value.object = create<object_t>();
            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

@@ -3868,8 +3899,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_value = value_t::array;
            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
            assert_invariant();
        }

@@ -3901,8 +3932,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_value = value_t::array;
            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
            assert_invariant();
        }

@@ -3933,8 +3964,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_value = value_t::object;
            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
            assert_invariant();
        }

@@ -3989,8 +4020,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_value = value_t::array;
            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
            assert_invariant();
        }

@@ -4014,8 +4045,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_value = value_t::object;
            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
            assert_invariant();
        }

@@ -4196,8 +4227,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_value.object = create<object_t>();
            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

@@ -6571,10 +6571,6 @@ namespace detail
 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
 * allocated value (e.g., a string). See bug issue
 * https://github.com/nlohmann/json/issues/2865 for more information.
- *
- * A value that has to be allocated is created before the old one is destroyed:
- * were it the other way around, an exception while creating the new value would
- * leave j with the type of the new value, but the pointer to the destroyed old one.
 */

 template<value_t> struct external_constructor;
@@ -6598,20 +6594,18 @@ struct external_constructor<value_t::string>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
-        const typename BasicJsonType::json_value value(s);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = value;
+        j.m_data.m_value = s;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
    {
-        const typename BasicJsonType::json_value value(std::move(s));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = value;
+        j.m_data.m_value = std::move(s);
        j.assert_invariant();
    }

@@ -6620,10 +6614,9 @@ struct external_constructor<value_t::string>
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
-        auto* created = j.template create<typename BasicJsonType::string_t>(str);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value.string = created;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
        j.assert_invariant();
    }
 };
@@ -6634,20 +6627,18 @@ struct external_constructor<value_t::binary>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
    {
-        const typename BasicJsonType::json_value value(b);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = value;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
    {
-        const typename BasicJsonType::json_value value(std::move(b));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = value;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
        j.assert_invariant();
    }
 };
@@ -6697,10 +6688,9 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
    {
-        const typename BasicJsonType::json_value value(arr);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
+        j.m_data.m_value = arr;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6708,10 +6698,9 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
    {
-        const typename BasicJsonType::json_value value(std::move(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
+        j.m_data.m_value = std::move(arr);
        j.set_parents();
        j.assert_invariant();
    }
@@ -6727,10 +6716,9 @@ struct external_constructor<value_t::array>
        using std::begin;
        using std::end;

-        auto* created = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value.array = created;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.set_parents();
        j.assert_invariant();
    }
@@ -6738,17 +6726,15 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
    {
-        typename BasicJsonType::array_t elements;
-        elements.reserve(arr.size());
-        for (const bool x : arr)
-        {
-            elements.push_back(x);
-        }
-        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
-        j.set_parents();
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
        j.assert_invariant();
    }

@@ -6756,12 +6742,11 @@ struct external_constructor<value_t::array>
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
    {
-        typename BasicJsonType::array_t elements(arr.size());
-        std::copy(std::begin(arr), std::end(arr), elements.begin());
-        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
        j.set_parents();
        j.assert_invariant();
    }
@@ -6773,16 +6758,14 @@ struct external_constructor<value_t::array>
             enable_if_t<is_compatible_range_view<std::remove_cvref_t<CompatibleArrayType>>::value, int> = 0>
    static void construct(BasicJsonType& j, CompatibleArrayType && arr)
    {
-        typename BasicJsonType::array_t elements;
-        for (auto&& x : std::forward<CompatibleArrayType>(arr))
-        {
-            elements.push_back(x);
-        }
-        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value;
-        j.set_parents();
+        j.m_data.m_value = value_t::array;
+        for (auto&& x : std::forward<CompatibleArrayType>(arr))
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
        j.assert_invariant();
    }
 #endif
@@ -6794,10 +6777,9 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
    {
-        const typename BasicJsonType::json_value value(obj);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = value;
+        j.m_data.m_value = obj;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6805,10 +6787,9 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
    {
-        const typename BasicJsonType::json_value value(std::move(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = value;
+        j.m_data.m_value = std::move(obj);
        j.set_parents();
        j.assert_invariant();
    }
@@ -6820,10 +6801,9 @@ struct external_constructor<value_t::object>
        using std::begin;
        using std::end;

-        auto* created = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value.object = created;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.set_parents();
        j.assert_invariant();
    }
@@ -6840,7 +6820,9 @@ void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept
 {
    if (opt.has_value())
    {
-        j = *opt;
+        // explicit construction, as the conversion from a basic_json with a different
+        // string type is explicit if JSON_USE_IMPLICIT_CONVERSIONS is 0 (#2649)
+        j = BasicJsonType(*opt);
    }
    else
    {
@@ -27508,12 +27490,42 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        assert_invariant();
    }

+  private:
+    /// whether a basic_json specialization can be converted implicitly into this one;
+    /// with JSON_USE_IMPLICIT_CONVERSIONS set to 0, this is only the case if both share
+    /// the same string type (see https://github.com/nlohmann/json/issues/2649)
+    template<typename BasicJsonType>
+    using is_implicitly_convertible_basic_json = std::integral_constant < bool,
+        (JSON_USE_IMPLICIT_CONVERSIONS != 0)
+        || std::is_same<typename BasicJsonType::string_t, string_t>::value >;
+
+    /// tag to select the constructor that performs the conversion from another basic_json specialization
+    struct convert_basic_json_tag {};
+
+  public:
    /// @brief create a JSON value from an existing one
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    template < typename BasicJsonType,
               detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
+                   && is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
    basic_json(const BasicJsonType& val)
+        : basic_json(val, convert_basic_json_tag{})
+    {}
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
+                   && !is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
+    explicit basic_json(const BasicJsonType& val)
+        : basic_json(val, convert_basic_json_tag{})
+    {}
+
+  private:
+    template<typename BasicJsonType>
+    basic_json(const BasicJsonType& val, convert_basic_json_tag /*unused*/)
 #if JSON_DIAGNOSTIC_POSITIONS
        : start_position(val.start_pos()),
          end_position(val.end_pos())
@@ -27569,6 +27581,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        assert_invariant();
    }

+  public:
    /// @brief create a container (array or object) from an initializer list
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(initializer_list_t init,
@@ -27605,8 +27618,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        if (is_an_object)
        {
            // the initializer list is a list of pairs -> create an object
-            m_data.m_value = value_t::object;
            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;

            for (auto& element_ref : init)
            {
@@ -27628,8 +27641,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            }
 #endif
            // the initializer list describes an array -> create an array
-            m_data.m_value.array = create<array_t>(init.begin(), init.end());
            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
        }

        set_parents();
@@ -27642,8 +27655,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init)
    {
        auto res = basic_json();
-        res.m_data.m_value = init;
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
        return res;
    }

@@ -27653,8 +27666,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_value = binary_t(init, subtype);
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
        return res;
    }

@@ -27664,8 +27677,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init)
    {
        auto res = basic_json();
-        res.m_data.m_value = std::move(init);
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
        return res;
    }

@@ -27675,8 +27688,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_value = binary_t(std::move(init), subtype);
        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
        return res;
    }

@@ -28335,7 +28348,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                   int > = 0 >
    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
    {
-        return *this;
+        return BasicJsonType(*this);
    }

    /*!
@@ -28474,7 +28487,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 int> = 0>
    ValueType & get_to(ValueType& v) const
    {
-        v = *this;
+        v = ValueType(*this);
        return v;
    }

@@ -28722,8 +28735,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty array
        if (is_null())
        {
-            m_data.m_value.array = create<array_t>();
            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
            assert_invariant();
        }

@@ -28782,8 +28795,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_value.object = create<object_t>();
            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

@@ -28835,8 +28848,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_value.object = create<object_t>();
            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

@@ -29771,8 +29784,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_value = value_t::array;
            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
            assert_invariant();
        }

@@ -29804,8 +29817,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_value = value_t::array;
            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
            assert_invariant();
        }

@@ -29836,8 +29849,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_value = value_t::object;
            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
            assert_invariant();
        }

@@ -29892,8 +29905,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_value = value_t::array;
            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
            assert_invariant();
        }

@@ -29917,8 +29930,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_value = value_t::object;
            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
            assert_invariant();
        }

@@ -30099,8 +30112,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_value.object = create<object_t>();
            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

@@ -12,11 +12,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

-#include <valarray>
-#if JSON_HAS_RANGES
-    #include <ranges>
-#endif
-
 namespace
 {
 // special test case to check if memory is leaked if constructor throws
@@ -399,173 +394,3 @@ TEST_CASE("bad my_allocator::construct")
        j["test"].push_back("should not leak");
    }
 }
-
-// the no-exceptions CI job skips every CHECK_THROWS_AS, which would leave
-// next_construct_fails set for the next allocation outside a check
-#if !defined(JSON_NOEXCEPTION)
-TEST_CASE("a failed allocation leaves the value unchanged")
-{
-    // create JSON type using the throwing allocator
-    using my_json = nlohmann::basic_json<std::map,
-          std::vector,
-          std::string,
-          bool,
-          std::int64_t,
-          std::uint64_t,
-          double,
-          my_allocator>;
-
-    // Each of these creates a string, array, object, or binary value. The
-    // value must be created before the type is changed: otherwise, a failed
-    // creation left a value of the new type without anything behind it (an
-    // assertion in its destructor, a null pointer everywhere else) or, when
-    // an old value was destroyed first, with a pointer to that destroyed one.
-
-    SECTION("creating a binary value")
-    {
-        const std::vector<std::uint8_t> bytes = {1, 2, 3};
-        my_json _;
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(_ = my_json::binary(bytes), std::bad_alloc&);
-        next_construct_fails = true;
-        CHECK_THROWS_AS(_ = my_json::binary(bytes, 42), std::bad_alloc&);
-        next_construct_fails = true;
-        CHECK_THROWS_AS(_ = my_json::binary(std::vector<std::uint8_t>(bytes)), std::bad_alloc&);
-        next_construct_fails = true;
-        CHECK_THROWS_AS(_ = my_json::binary(std::vector<std::uint8_t>(bytes), 42), std::bad_alloc&);
-        next_construct_fails = false;
-    }
-
-    SECTION("turning a null value into an array or object")
-    {
-        my_json j;
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j[0], std::bad_alloc&);
-        CHECK(j.is_null());
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j["key"], std::bad_alloc&);
-        CHECK(j.is_null());
-
-#ifdef JSON_HAS_CPP_17
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j[std::string_view("key")], std::bad_alloc&);
-        CHECK(j.is_null());
-#endif
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j.push_back(my_json(1)), std::bad_alloc&);
-        CHECK(j.is_null());
-
-        const my_json one = 1;
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j.push_back(one), std::bad_alloc&);
-        CHECK(j.is_null());
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j.push_back(my_json::object_t::value_type("key", 1)), std::bad_alloc&);
-        CHECK(j.is_null());
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j.emplace_back(1), std::bad_alloc&);
-        CHECK(j.is_null());
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j.emplace("key", 1), std::bad_alloc&);
-        CHECK(j.is_null());
-
-        const my_json object = {{"key", 1}};
-        next_construct_fails = true;
-        CHECK_THROWS_AS(j.update(object), std::bad_alloc&);
-        CHECK(j.is_null());
-
-        next_construct_fails = false;
-    }
-
-    SECTION("converting into an existing value")
-    {
-        // to_json replaces the value it is given; the old one must survive a
-        // failed creation of the new one
-        my_json j = "old";
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::string("new")), std::bad_alloc&);
-        CHECK(j == "old");
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::vector<int> {1, 2}), std::bad_alloc&);
-        CHECK(j == "old");
-
-        // with iterator debugging, the default constructor of VS 2015's
-        // std::vector is noexcept but constructs a proxy with the allocator,
-        // which terminates when this allocator throws
-#if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::vector<bool> {true, false}), std::bad_alloc&);
-        CHECK(j == "old");
-#endif
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::map<std::string, int> {{"a", 1}}), std::bad_alloc&);
-        CHECK(j == "old");
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, my_json::binary_t({1, 2})), std::bad_alloc&);
-        CHECK(j == "old");
-
-        // the overloads for lvalues of the value types, for the value types
-        // themselves, and for the remaining compatible types
-        const std::string string = "new";
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, string), std::bad_alloc&);
-        CHECK(j == "old");
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, "new"), std::bad_alloc&);
-        CHECK(j == "old");
-
-        // to_json only moves a binary value that it converted from another
-        // container type, which my_json's std::vector<std::uint8_t> is not
-        using binary_constructor = nlohmann::detail::external_constructor<nlohmann::detail::value_t::binary>;
-        next_construct_fails = true;
-        CHECK_THROWS_AS(binary_constructor::construct(j, my_json::binary_t({1, 2})), std::bad_alloc&);
-        CHECK(j == "old");
-
-        my_json::array_t array = {1, 2};
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, array), std::bad_alloc&);
-        CHECK(j == "old");
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::move(array)), std::bad_alloc&);
-        CHECK(j == "old");
-
-        my_json::object_t object = {{"a", 1}};
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, object), std::bad_alloc&);
-        CHECK(j == "old");
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::move(object)), std::bad_alloc&);
-        CHECK(j == "old");
-
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, std::valarray<int> {1, 2}), std::bad_alloc&);
-        CHECK(j == "old");
-
-#if JSON_HAS_RANGES && !defined(__MINGW32__)
-        const std::vector<int> numbers = {1, 2};
-        next_construct_fails = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, numbers | std::views::filter([](int /*unused*/)
-        {
-            return true;
-        })), std::bad_alloc&);
-        CHECK(j == "old");
-#endif
-
-        next_construct_fails = false;
-        nlohmann::to_json(j, std::vector<int> {1, 2});
-        CHECK(j == my_json({1, 2}));
-    }
-}
-#endif
@@ -13,6 +13,7 @@

 #include <cstdint>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>

@@ -374,4 +375,39 @@ TEST_CASE("alternative string type")
        const auto j2 = j.flatten();
        CHECK(j2.dump() == R"({"/foo/0":"bar","/foo/1":"baz"})");
    }
+
+    SECTION("conversion between basic_json specializations (#2649)")
+    {
+        // explicit conversions are always possible
+        CHECK(std::is_constructible<nlohmann::json, alt_json>::value);
+        CHECK(std::is_constructible<alt_json, nlohmann::json>::value);
+        CHECK(std::is_constructible<nlohmann::json, nlohmann::ordered_json>::value);
+        CHECK(std::is_constructible<nlohmann::ordered_json, nlohmann::json>::value);
+
+        // specializations with the same string type are implicitly convertible
+        CHECK(std::is_convertible<nlohmann::ordered_json, nlohmann::json>::value);
+        CHECK(std::is_convertible<nlohmann::json, nlohmann::ordered_json>::value);
+
+        // specializations with different string types are only implicitly convertible
+        // if implicit conversions are enabled
+#if JSON_USE_IMPLICIT_CONVERSIONS
+        CHECK(std::is_convertible<alt_json, nlohmann::json>::value);
+        CHECK(std::is_convertible<nlohmann::json, alt_json>::value);
+#else
+        CHECK_FALSE(std::is_convertible<alt_json, nlohmann::json>::value);
+        CHECK_FALSE(std::is_convertible<nlohmann::json, alt_json>::value);
+#endif
+
+        // get<BasicJsonType>() works in either case
+        const nlohmann::json j = {{"foo", 1}, {"bar", true}};
+        CHECK(j.get<nlohmann::ordered_json>() == nlohmann::ordered_json(j));
+        // (only a number is converted here, as objects and strings are affected by #3425)
+        CHECK(nlohmann::json(42).get<alt_json>() == 42);
+        CHECK(alt_json(nlohmann::json(42)) == 42);
+
+        // get_to() also works in either case
+        alt_json a;
+        nlohmann::json(42).get_to(a);
+        CHECK(a == 42);
+    }
 }