From 8e85d1d19148da4108fde144040ea8f49eb837dc Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Wed, 26 Aug 2026 20:49:09 +0300
Subject: [PATCH 1/5] Reproduce test from issue
 https://github.com/boostorg/lexical_cast/issues/101

---
 test/arrays_test.cpp | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/test/arrays_test.cpp b/test/arrays_test.cpp
index 298ec86..cfaed7a 100644
--- a/test/arrays_test.cpp
+++ b/test/arrays_test.cpp
@@ -24,6 +24,22 @@ using namespace boost;
 #define BOOST_LC_RUNU32
 #endif
 
+namespace user_namespace {
+
+struct user_type{};
+
+template <std::size_t Size>
+inline std::ostream& operator<<(std::ostream& os, const boost::array<user_type, Size>& ) {
+    return os << "array<user_type, " << Size << ">";
+}
+
+template <std::size_t Size>
+inline std::ostream& operator<<(std::ostream& os, const std::array<user_type, Size>& ) {
+    return os << "array<user_type, " << Size << ">";
+}
+
+}
+
 template <template <class, std::size_t> class ArrayT, class T>
 static void testing_template_array_output_on_spec_value(T val)
 {
@@ -33,6 +49,7 @@ static void testing_template_array_output_on_spec_value(T val)
     typedef ArrayT<unsigned char, 1>      ushort_arr_type;
     typedef ArrayT<signed char, 4>        sarr_type;
     typedef ArrayT<signed char, 3>        sshort_arr_type;
+    typedef ArrayT<user_namespace::user_type, 2> user_arr_type;
 
     std::string ethalon("100");
     using namespace std;
@@ -61,6 +78,14 @@ static void testing_template_array_output_on_spec_value(T val)
         BOOST_TEST_THROWS(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
     }
 
+    {
+        auto res1 = lexical_cast<std::string>(user_arr_type{
+            user_namespace::user_type{},
+            user_namespace::user_type{},
+        });
+        BOOST_TEST_EQ(res1, "array<user_type, 2>");
+    }
+
 #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING) && !defined(_LIBCPP_VERSION)
     typedef ArrayT<wchar_t, 300> warr_type;
     typedef ArrayT<wchar_t, 3> wshort_arr_type;
@@ -249,13 +274,11 @@ void testing_boost_array_output_conversion()
 
 void testing_std_array_output_conversion()
 {
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
     testing_template_array_output_on_char_value<std::array>();
     testing_template_array_output_on_spec_value<std::array>(100);
     testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
     testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned short>(100));
     testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
-#endif
 
     BOOST_TEST(true);
 }
@@ -354,10 +377,7 @@ void testing_boost_array_input_conversion()
 
 void testing_std_array_input_conversion()
 {
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
     testing_generic_array_input_conversion<std::array>();
-#endif
-
     BOOST_TEST(true);
 }
 

From 323dd7c8fb88de6c352d54ba0eb25bfaeb69a8a8 Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Wed, 26 Aug 2026 21:03:30 +0300
Subject: [PATCH 2/5] reproduced

---
 test/arrays_test.cpp | 102 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 94 insertions(+), 8 deletions(-)

diff --git a/test/arrays_test.cpp b/test/arrays_test.cpp
index cfaed7a..33bcd17 100644
--- a/test/arrays_test.cpp
+++ b/test/arrays_test.cpp
@@ -26,16 +26,85 @@ using namespace boost;
 
 namespace user_namespace {
 
-struct user_type{};
+struct user_type {
+    char payload;
+};
 
 template <std::size_t Size>
-inline std::ostream& operator<<(std::ostream& os, const boost::array<user_type, Size>& ) {
-    return os << "array<user_type, " << Size << ">";
+inline std::ostream& operator<<(std::ostream& os, const boost::array<user_type, Size>& array) {
+    for (const auto& x : array) {
+        os << '@' << x.payload;
+    }
+    return os;
+}
+
+template <std::size_t Size>
+inline std::ostream& operator<<(std::ostream& os, const std::array<user_type, Size>& array) {
+    for (const auto& x : array) {
+        os << '@' << x.payload;
+    }
+    return os;
+}
+
+template <std::size_t Size>
+inline std::istream& operator>>(std::istream& is, boost::array<user_type, Size>& array) {
+    for (auto& x : array) {
+        char at{};
+        is >> at >> x.payload;
+        BOOST_TEST_EQ(at, 'a');
+    }
+    return is;
 }
 
 template <std::size_t Size>
-inline std::ostream& operator<<(std::ostream& os, const std::array<user_type, Size>& ) {
-    return os << "array<user_type, " << Size << ">";
+inline std::istream& operator>>(std::istream& is, std::array<user_type, Size>& array) {
+    for (auto& x : array) {
+        char at{};
+        is >> at >> x.payload;
+    }
+    return is;
+}
+
+
+
+struct another_user_type {
+    char payload;
+    char payload1 = '-';
+};
+
+template <std::size_t Size>
+inline std::ostream& operator<<(std::ostream& os, const boost::array<another_user_type, Size>& array) {
+    for (const auto& x : array) {
+        os << '@' << x.payload;
+    }
+    return os;
+}
+
+template <std::size_t Size>
+inline std::ostream& operator<<(std::ostream& os, const std::array<another_user_type, Size>& array) {
+    for (const auto& x : array) {
+        os << '@' << x.payload;
+    }
+    return os;
+}
+
+template <std::size_t Size>
+inline std::istream& operator>>(std::istream& is, boost::array<another_user_type, Size>& array) {
+    for (auto& x : array) {
+        char at{};
+        is >> at >> x.payload;
+        BOOST_TEST_EQ(at, 'a');
+    }
+    return is;
+}
+
+template <std::size_t Size>
+inline std::istream& operator>>(std::istream& is, std::array<user_type, Size>& array) {
+    for (auto& x : array) {
+        char at{};
+        is >> at >> x.payload;
+    }
+    return is;
 }
 
 }
@@ -50,6 +119,7 @@ static void testing_template_array_output_on_spec_value(T val)
     typedef ArrayT<signed char, 4>        sarr_type;
     typedef ArrayT<signed char, 3>        sshort_arr_type;
     typedef ArrayT<user_namespace::user_type, 2> user_arr_type;
+    typedef ArrayT<user_namespace::another_user_type, 2> another_user_arr_type;
 
     std::string ethalon("100");
     using namespace std;
@@ -80,10 +150,26 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         auto res1 = lexical_cast<std::string>(user_arr_type{
-            user_namespace::user_type{},
-            user_namespace::user_type{},
+            user_namespace::user_type{'a'},
+            user_namespace::user_type{'z'},
+        });
+        BOOST_TEST_EQ(res1, "@a@z");
+
+        auto res2 = lexical_cast<user_arr_type>("@b@y");
+        BOOST_TEST_EQ(res2[0].payload, 'b');
+        BOOST_TEST_EQ(res2[1].payload, 'y');
+    }
+
+    {
+        auto res1 = lexical_cast<std::string>(another_user_arr_type{
+            user_namespace::another_user_type{'a'},
+            user_namespace::another_user_type{'z'},
         });
-        BOOST_TEST_EQ(res1, "array<user_type, 2>");
+        BOOST_TEST_EQ(res1, "@a@z");
+
+        auto res2 = lexical_cast<another_user_arr_type>("@b@y");
+        BOOST_TEST_EQ(res2[0].payload, 'b');
+        BOOST_TEST_EQ(res2[1].payload, 'y');
     }
 
 #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING) && !defined(_LIBCPP_VERSION)

From 55b9f5bd52756a457e56e02cd5d44bcb46737f5b Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Thu, 27 Aug 2026 17:45:23 +0300
Subject: [PATCH 3/5] fix

---
 .../detail/converter_lexical_streams.hpp      | 40 +++++++++----------
 test/arrays_test.cpp                          |  6 +--
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/include/boost/lexical_cast/detail/converter_lexical_streams.hpp b/include/boost/lexical_cast/detail/converter_lexical_streams.hpp
index f2e8e08..d7e5b31 100644
--- a/include/boost/lexical_cast/detail/converter_lexical_streams.hpp
+++ b/include/boost/lexical_cast/detail/converter_lexical_streams.hpp
@@ -96,6 +96,16 @@ namespace boost {
 
 namespace boost { namespace detail { namespace lcast {
 
+    template <class C, class CharT>
+    using enable_if_compatible_char_t = typename std::enable_if<
+        std::is_same<const C, const CharT>::value || (
+            std::is_same<const char, const CharT>::value && (
+                std::is_same<const C, const unsigned char>::value ||
+                std::is_same<const C, const signed char>::value
+            )
+        ), bool
+    >::type;
+
     template <typename T>
     struct exact {
         static_assert(!std::is_const<T>::value, "");
@@ -256,16 +266,6 @@ namespace boost { namespace detail { namespace lcast {
         }
 #endif
     public:
-        template <class C>
-        using enable_if_compatible_char_t = typename std::enable_if<
-            std::is_same<const C, const CharT>::value || (
-                std::is_same<const char, const CharT>::value && (
-                    std::is_same<const C, const unsigned char>::value ||
-                    std::is_same<const C, const signed char>::value
-                )
-            ), bool
-        >::type;
-
         template<class CharTraits, class Alloc>
         bool stream_in(lcast::exact<std::basic_string<CharT,CharTraits,Alloc>> x) noexcept {
             start = x.payload.data();
@@ -294,7 +294,7 @@ namespace boost { namespace detail { namespace lcast {
         }
 
         template <class C>
-        enable_if_compatible_char_t<C>
+        enable_if_compatible_char_t<C, CharT>
         stream_in(lcast::exact<boost::iterator_range<C*>> x) noexcept {
             auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
             return stream_in(lcast::exact<decltype(buf)>{buf});
@@ -311,7 +311,7 @@ namespace boost { namespace detail { namespace lcast {
 #endif
 
         template <class Type>
-        enable_if_compatible_char_t<Type>
+        enable_if_compatible_char_t<Type, CharT>
                 stream_in(lcast::exact<Type*> x)                { return shl_char_array(reinterpret_cast<CharT const*>(x.payload)); }
 
         template <class Type>
@@ -334,20 +334,20 @@ namespace boost { namespace detail { namespace lcast {
         }
 
         template <class C, std::size_t N>
-        enable_if_compatible_char_t<C>
+        enable_if_compatible_char_t<C, CharT>
         stream_in(lcast::exact<boost::array<C, N>> x) noexcept {
             return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), N);
         }
 
         template <class C, std::size_t N>
-        enable_if_compatible_char_t<C>
+        enable_if_compatible_char_t<C, CharT>
         stream_in(lcast::exact<std::array<C, N>> x) noexcept {
             return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), N);
         }
 
 #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
         template <class C, class CharTraits>
-        enable_if_compatible_char_t<C>
+        enable_if_compatible_char_t<C, CharT>
         stream_in(lcast::exact<std::basic_string_view<C, CharTraits>> x) noexcept {
             start = reinterpret_cast<const CharT*>(x.payload.data());
             finish = start + x.payload.size();
@@ -355,7 +355,7 @@ namespace boost { namespace detail { namespace lcast {
         }
 #endif
         template <class C, class CharTraits>
-        enable_if_compatible_char_t<C>
+        enable_if_compatible_char_t<C, CharT>
         stream_in(lcast::exact<boost::basic_string_view<C, CharTraits>> x) noexcept {
             start = reinterpret_cast<const CharT*>(x.payload.data());
             finish = start + x.payload.size();
@@ -667,14 +667,14 @@ namespace boost { namespace detail { namespace lcast {
         }
 
         template <class C, std::size_t N>
-        bool stream_out(std::array<C, N>& output) noexcept {
-            static_assert(sizeof(C) == sizeof(CharT), "");
+        enable_if_compatible_char_t<C, CharT>
+        stream_out(std::array<C, N>& output) noexcept {
             return shr_std_array<N>(output);
         }
 
         template <class C, std::size_t N>
-        bool stream_out(boost::array<C, N>& output) noexcept {
-            static_assert(sizeof(C) == sizeof(CharT), "");
+        enable_if_compatible_char_t<C, CharT>
+        stream_out(boost::array<C, N>& output) noexcept {
             return shr_std_array<N>(output);
         }
 
diff --git a/test/arrays_test.cpp b/test/arrays_test.cpp
index 33bcd17..2bc7404 100644
--- a/test/arrays_test.cpp
+++ b/test/arrays_test.cpp
@@ -51,7 +51,7 @@ inline std::istream& operator>>(std::istream& is, boost::array<user_type, Size>&
     for (auto& x : array) {
         char at{};
         is >> at >> x.payload;
-        BOOST_TEST_EQ(at, 'a');
+        BOOST_TEST_EQ(at, '@');
     }
     return is;
 }
@@ -93,13 +93,13 @@ inline std::istream& operator>>(std::istream& is, boost::array<another_user_type
     for (auto& x : array) {
         char at{};
         is >> at >> x.payload;
-        BOOST_TEST_EQ(at, 'a');
+        BOOST_TEST_EQ(at, '@');
     }
     return is;
 }
 
 template <std::size_t Size>
-inline std::istream& operator>>(std::istream& is, std::array<user_type, Size>& array) {
+inline std::istream& operator>>(std::istream& is, std::array<another_user_type, Size>& array) {
     for (auto& x : array) {
         char at{};
         is >> at >> x.payload;

From ca4740267943f2f29fc9063d88850683e11a241d Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Fri, 28 Aug 2026 18:26:38 +0300
Subject: [PATCH 4/5] fix

---
 test/arrays_test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/arrays_test.cpp b/test/arrays_test.cpp
index 2bc7404..a0da3b0 100644
--- a/test/arrays_test.cpp
+++ b/test/arrays_test.cpp
@@ -162,8 +162,8 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         auto res1 = lexical_cast<std::string>(another_user_arr_type{
-            user_namespace::another_user_type{'a'},
-            user_namespace::another_user_type{'z'},
+            user_namespace::another_user_type{'a', '-'},
+            user_namespace::another_user_type{'z', '-'},
         });
         BOOST_TEST_EQ(res1, "@a@z");
 

From c722e5325355d7a18d598d05e6df81c10a1b234d Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Fri, 28 Aug 2026 20:37:12 +0300
Subject: [PATCH 5/5] fix

---
 test/arrays_test.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/test/arrays_test.cpp b/test/arrays_test.cpp
index a0da3b0..ea09039 100644
--- a/test/arrays_test.cpp
+++ b/test/arrays_test.cpp
@@ -68,8 +68,18 @@ inline std::istream& operator>>(std::istream& is, std::array<user_type, Size>& a
 
 
 struct another_user_type {
+    another_user_type()
+        : payload('\0')
+        , payload1('-')
+    {}
+
+    another_user_type(char in_payload, char in_payload1)
+        : payload(in_payload)
+        , payload1(in_payload1)
+    {}
+
     char payload;
-    char payload1 = '-';
+    char payload1;
 };
 
 template <std::size_t Size>
@@ -162,8 +172,8 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         auto res1 = lexical_cast<std::string>(another_user_arr_type{
-            user_namespace::another_user_type{'a', '-'},
-            user_namespace::another_user_type{'z', '-'},
+            user_namespace::another_user_type('a', '-'),
+            user_namespace::another_user_type('z', '-'),
         });
         BOOST_TEST_EQ(res1, "@a@z");