How can I check if a template type parameter is a character type or a string type?

Question

I am trying to write code that will be able to distinguish between character types (char, wchar_t, etc.), string types (std::string, std::wstring, etc.), and numeric types, so I can enclose characters in single-quotes and strings in double-quotes. The idea is to treat values differently depending on how they are output. Characters and strings are fundamentally different from numeric values, because they display according to an encoding representation of their contents (i.e., ASCII, Unicode, UTF, etc.), rather than as numeric values.

(Note: this code is extracted from a much larger and more complicated program)

Here's my code, compiled with

g++ -std=c++14 testchar.cpp -o testchar

which works under Linux Mint 18.3 (Sylvia) compiled with g++ v5.4.0

#include <iostream>
#include <locale>
#include <codecvt>
#include <string>
#include <type_traits>

using std::cout;
using std::is_same;
using std::string;
using std::u16string;
using std::u32string;
using std::wstring;

#define is_string_type(T)  ( is_same<T,string>::value    || is_same<T,wstring>::value   || \
                             is_same<T,u16string>::value || is_same<T,u32string>::value )
#define is_char_type(T)    ( is_same<T,char>::value      || is_same<T,wchar_t>::value   || \
                             is_same<T,char16_t>::value  || is_same<T,char32_t>::value  )
#define is_numeric_type(T) ( !is_char_type(T) && std::is_arithmetic<T>::value )

template <typename T>
typename std::enable_if<is_string_type(T),void>::type
output_value( const string& name, const T& strval ) {
    cout << "String " << name << " is \"" << strval << "\";\n";
}
template <typename T>
typename std::enable_if<is_char_type(T),void>::type
output_value( const string& name, const T& chrval ) {
    cout << "Character " << name << " is '" << chrval << "';\n";
}
template <typename T>
typename std::enable_if<is_numeric_type(T),void>::type
output_value( const string& name, const T& val ) {
    cout << "Numeric " << name << " is " << val << ";\n";
}

int main(void)
{
    string    name;
    short     sval = 4321;
    int       ival = 123;
    long      lval = 1234567890L;
    char      cval = 'W';
    string    Sval = "string";

    name = "sval";
    output_value( name, sval );
    name = "ival";
    output_value( name, ival );
    name = "lval";
    output_value( name, lval );
    name = "cval";
    output_value( name, cval );
    name = "strval";
    output_value( name, Sval );

    return 0;
}

But my macros, 'is_char_type' and 'is_string_type' are ugly and not very robust. And they are macros... yuck! I did try using std::is_base_of<std::basic_string,T>::value for `is_string_type', but the compiler threw an error:

testchar.cpp:17:65: error: type/value mismatch at argument 1 in template parameter list for ‘template<class, class> struct std::is_base_of’

If anyone knows a better way to do this please let me know! I'm kind of surprised these (is_character_type and is_string_type) don't already exist in type_traits... or perhaps they do, but are cleverly disguised?

Answer 1

template<class T>struct tag_t{};
template<class T>constexpr tag_t<T> tag{};
namespace detect_string {
  template<class T, class...Ts>
  constexpr bool is_stringlike(tag_t<T>, Ts&&...){ return false; }
  template<class T, class A>
  constexpr bool is_stringlike( tag_t<std::basic_string<T,A>> ){ return true; }
  template<class T>
  constexpr bool detect=is_stringlike(tag<T>); // enable ADL extension
}
namespace detect_character {
  template<class T, class...Ts>
  constexpr bool is_charlike(tag_t<T>, Ts&&...){ return false; }
  constexpr bool is_charlike( tag_t<char> ){ return true; }
  constexpr bool is_charlike( tag_t<wchar_t> ){ return true; }
  // ETC
  template<class T>
  constexpr bool detect=is_charlike(tag<T>); // enable ADL extension
}

now detect_character::detect<char> is true, as is detect_string::detect<std::wstring>.

If you want only strings of charlikes to be strings, add it to the is_stringlike overload.

You can extend either of these by defining within the namespace of a type X a is_stringlike(tag_t<X>) overload, and it will be automatically found. Or doing so in detect_stringlike. You may not add overloads to std in this way, so do them in the detect_stringlike namespace.

There are other solutions, but this is the only one that avoids the fragility of a single central list.

Answer 2

Following patterns in the std template library you could write helpers as follows:

// Given `std::` namespace ...
template <bool _Val>
using bool_constant = integral_constant<bool, _Val>;

// EdgeS AfBox `pal::` namespace - platform-abstraction-layer type support
// Char8, UChar8, SChar8, UChar16t, WChar16, UChar16, UChar32
typedef char8_t                         UChar8t;
typedef unsigned char                   UChar8;
typedef signed char                     SChar8;
typedef char                             Char8;
// ..other defn's elided..

// EdgeS AfBox `pal::` namespace - platform-abstraction-layer type support
template<typename T>
constexpr bool is_char_type_v = std::_Is_any_of_v<std::remove_cv_t<T>,
  Char8, UChar8, SChar8, UChar16t, WChar16, UChar16, UChar32>;
template<typename T>
struct is_char_type : std::bool_constant <is_char_type_v<T>> {};

// Use it as follows:
template<typename char_ta,
  typename std::enable_if<pal::is_char_type<char_ta>::value>::type* = nullptr>
void populate_arg(AfBlob&& bArgs, char_ta* z) {
  //..ellided..
}