C++ Convert any character sequence to any standard string

This is the second part of C++ : codecvt deprecated. Panic?

Update

Four standard char types can be transformed to each other
Four standard char types can be transformed into each other. And if you are brave there is a fifth_one in C++20: char8_t

Due to popular acclaim, I have made and published a stand-alone and fully functional code described in this post. It is in the form of Github Gist here.

It is also updated and optimized. Enjoy …

Update

This is not a foreign language translator or some such code.  This is a standard  C++ 17 utility to transform the core character sets between each other.  The first 127 characters, that is. As such it is remarkably useful and simple. For full-blown, locale-aware solutions please look elsewhere, starting from here.  End of update.

Standard C++ std lib, is one very complete and useful library. But there are times when you do realize you can build one or two of very simple utilities on top of it.

Simple but sometimes surprisingly powerful. Like perhaps this one is.

A mechanism for transforming any standard sequence of chars (i.e. holding standard char types),  into any of the four standard string types.  Which are:

dbj meta converter target types
Type Definition
std::string std::basic_string<char>
std::wstring std::basic_string<wchar_t>
std::u16string (C++11) std::basic_string<char16_t>
std::u32string (C++11) std::basic_string<char32_t>
std::u8string (C++20) std::basic_string<char8_t>

First the reason you are here, The synopsis of the code:

namespace dbj {
namespace inner {
// (c) 2018 by dbj.org, 
// Disclaimer, Terms and Conditions:
// https://dbj.org/disclaimer/
//
template < typename return_type >
struct meta_converter final 
{
template<typename T>
  return_type operator () (T arg)
{
if constexpr (dbj::is_range_v<T>) {
     return { arg.begin(), arg.end() };
 }
else {
 using actual_type 
    = std::remove_cv_t< T >;
return this->operator()(
    std::basic_string<actual_type>{ arg }
);
  }
 }
}; // meta_converter
} // inner
// all the types required / implicit instantiations
using char_range_to_string
  = inner::meta_converter<std::string   >;
using wchar_range_to_string
  = inner::meta_converter<std::wstring  >;
using u16char_range_to_string   
  = inner::meta_converter<std::u16string>;
using u32char_range_to_string   
  = inner::meta_converter<std::u32string>;

} // dbj

The full standalone implementation is here. One struct with one function call operator, does it all.  Usage:

// make a converter to convert to
// std:string
dbj::char_range_to_string  string_conv{};

// all of the bellow will do the conversion
auto s1 = string_conv( "\"the\0\0standard string literal\""s));
// array to string
auto s2 = string_conv(
   std::array<wchar_t , 6>{ L'H', L'e', L'l', L'l', L'o', L'!'}
);
// vector to string
auto s2 = string_conv(
   std::vector<wchar_t>{ L'H', L'e', L'l', L'l', L'o', L'!'}
);

And so on. Any standard sequence made up of standard chars will do as an legal input.  As long as it has begin() and end() methods, and the value_type typedef. Including native string literals too.

// make a converter to convert to
// std:string
dbj::char_range_to_string  string_conv{};

// native string literals are ok
auto s1 = string_conv(  "the native string literal"));
auto s2 = string_conv( L"wide native string literal"));
auto s3 = string_conv( u"u16char native string literal"));
auto s3 = string_conv( U"u32char native string literal"));

We could also serve stunt programmers to a certain extent, too:

// converter
dbj::wchar_range_to_string  to_wstring{};
// we can serve stunt men to
// convert for example an reference to
// array of chars into std::wstring
auto ws_ = to_wstring(
static_cast<const char(&)[]>
   ( "Abra Ca Dabra") 
);

Perhaps (one might remark) we could code this in a more “resilient” way. And I did, github gist is here.

And after all it is certainly wise to wait for C++20 constraints and concept’s to appear soon in a compiler near you. Applying that standard feature, will certainly make for one resilient and more user friendly version.

In case you would like to try this yourself do mail us, please.