diff --git a/include/boost/lexical_cast.hpp b/include/boost/lexical_cast.hpp
index 7874743..9e0a7af 100644
--- a/include/boost/lexical_cast.hpp
+++ b/include/boost/lexical_cast.hpp
@@ -1000,6 +1000,11 @@ namespace boost
         };
     }
 
+    namespace detail
+    {
+        struct do_not_construct_stringbuffer_t{};
+    }
+
     namespace detail // optimized stream wrapper
     {
         // String representation of Source has an upper limit.
@@ -1021,7 +1026,7 @@ namespace boost
             typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c<
                 RequiresStringbuffer,
                 local_stringbuffer_t,
-                char
+                do_not_construct_stringbuffer_t
             >::type deduced_stringbuffer_t;
 
             // A string representation of Source is written to [start, finish).
@@ -1210,13 +1215,17 @@ namespace boost
             bool operator<<(signed char ch)             { return ((*this) << static_cast<char>(ch)); }
 #if !defined(BOOST_LCAST_NO_WCHAR_T)
             bool operator<<(wchar_t const* str)         { return shl_char_array(str); }
+            bool operator<<(wchar_t * str)              { return shl_char_array(str); }
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
             bool operator<<(wchar_t ch)                 { return shl_char(ch); }
 #endif
 #endif
             bool operator<<(unsigned char const* ch)    { return ((*this) << reinterpret_cast<char const*>(ch)); }
+            bool operator<<(unsigned char * ch)         { return ((*this) << reinterpret_cast<char *>(ch)); }
             bool operator<<(signed char const* ch)      { return ((*this) << reinterpret_cast<char const*>(ch)); }
+            bool operator<<(signed char * ch)           { return ((*this) << reinterpret_cast<char *>(ch)); }
             bool operator<<(char const* str)            { return shl_char_array(str); }
+            bool operator<<(char* str)                  { return shl_char_array(str); }
             bool operator<<(short n)                    { return shl_signed(n); }
             bool operator<<(int n)                      { return shl_signed(n); }
             bool operator<<(long n)                     { return shl_signed(n); }
diff --git a/lexical_cast_test.cpp b/lexical_cast_test.cpp
index 244addb..37753ca 100644
--- a/lexical_cast_test.cpp
+++ b/lexical_cast_test.cpp
@@ -35,6 +35,7 @@
 
 #include <boost/type_traits/integral_promotion.hpp>
 #include <string>
+#include <vector>
 #include <memory>
 
 #if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
@@ -69,6 +70,7 @@ void test_conversion_to_char();
 void test_conversion_to_int();
 void test_conversion_to_double();
 void test_conversion_to_bool();
+void test_conversion_with_nonconst_char();
 void test_conversion_to_string();
 void test_conversion_from_to_wchar_t_alias();
 void test_conversion_to_pointer();
@@ -109,6 +111,7 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
     suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
     suite->add(BOOST_TEST_CASE(test_conversion_to_pointer));
     suite->add(BOOST_TEST_CASE(test_conversion_to_string));
+    suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
 #ifndef BOOST_LCAST_NO_WCHAR_T
     suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
     suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
@@ -199,6 +202,31 @@ void test_conversion_to_int()
         lexical_cast<int>(std::string("Test")), bad_lexical_cast);
 }
 
+void test_conversion_with_nonconst_char()
+{
+    std::vector<char> buffer;
+    buffer.push_back('1');
+    buffer.push_back('\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer[0]), 1);
+
+    std::vector<unsigned char> buffer2;
+    buffer2.push_back('1');
+    buffer2.push_back('\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer2[0]), 1);
+
+    std::vector<unsigned char> buffer3;
+    buffer3.push_back('1');
+    buffer3.push_back('\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer3[0]), 1);
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    std::vector<wchar_t> buffer4;
+    buffer4.push_back(L'1');
+    buffer4.push_back(L'\0');
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer4[0]), 1);
+#endif
+}
+
 void test_conversion_to_double()
 {
     BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));