how to tell if a C++ template type is C-style string

Question

I am trying to write a template is_c_str to test if a type is a c-style string. I need this as an attempt to write a to_string function, as shown in my other question here: Template specialization for iterators of STL containers?.

I need to tell apart c_str and other types of pointers and iterators, so that I can represent the first at the face value, and render pointers/iterators as an opaque "itor" or "ptr". The code is as follows:

#include <iostream>
template<class T>
struct is_c_str
  : std::integral_constant<
  bool,
  !std::is_same<char *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value
> {};

int main() {
  auto sz = "Hello";  //Or: const char * sz = "Hello";
  int i;
  double d;
  std::cout << is_c_str<decltype(sz)>::value << ", "
        << is_c_str<decltype(i)>::value << ", "
        << is_c_str<decltype(d)>::value << std::endl;
}

However, is_c_str captures not only const char *, but also int and double. The above code outputs:

1, 1, 1

(as of gcc-4.8.1).

My question is how to fix is_c_str to properly capture c-style strings?

Answer 1

You want to check if the type is the same as a char *, but you're negating the result of std::is_same, which is clearly not going to produce the correct result. So let's remove that.

template<class T>
struct is_c_str
  : std::integral_constant<
      bool,
      std::is_same<char *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value
> {};

However, this is now going to result in the output 0, 0, 0. The problem now is that remove_cv removes top-level cv-qualifiers, but the const in char const * is not top-level.

---

If you want to match both char * and char const * the easiest solution is:

template<class T>
struct is_c_str
  : std::integral_constant<
      bool,
      std::is_same<char *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value ||
      std::is_same<char const *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value
> {};

The above version will still not match char[]. If you want to match those too, and reduce the verbosity of combining std::remove_reference and std::remove_cv, use std::decay instead.

template<class T>
struct is_c_str
  : std::integral_constant<
      bool,
      std::is_same<char const *, typename std::decay<T>::type>::value ||
      std::is_same<char *, typename std::decay<T>::type>::value
> {};

Answer 2

I tried this and it seems to work:

#include <iostream>

template<class T>
struct is_c_str : std::integral_constant<bool, false> {};

template<>
struct is_c_str<char*> : std::integral_constant<bool, true> {};

template<>
struct is_c_str<const char*> : std::integral_constant<bool, true> {};

int main() {
  auto sz = "Hello";
  int i;
  double d;
  std::cout << is_c_str<decltype(sz)>::value << ", "
        << is_c_str<decltype(i)>::value << ", "
        << is_c_str<decltype(d)>::value << std::endl;
}

Obviously enumerating every case is not as elegant as putting the general predicate in std:integral_constant, but on the other hand that predicate is alien tongue for idiots like me, while the "brute force" template specialization is somewhat more comprehensible, and viable in this case as there are few specializations.

Answer 3

The type of sz is char const*, but std::remove_cv<> only removes top-level const, so you can't get char* through its application. Instead, you can just check for a char const* after completely decomposing the type with std::decay<>:

namespace detail
{
    template<class T>
    struct is_c_str : std::is_same<char const*, T> {};
}

template<class T>
struct is_c_str : detail::is_c_str<typename std::decay<T>::type> {};

int main() {
  auto sz = "Hello";
  int i;
  double d;
  std::cout << is_c_str<decltype(sz)>::value << ", "
            << is_c_str<decltype(i)>::value << ", "
            << is_c_str<decltype(d)>::value << std::endl;
}

You were also falsely negating the condition. I fixed that as well.

Live Example

Answer 4

There are a few solutions already, but since the simplest solution is really simple, I'll jot it down here.

template< typename, typename = void >
struct is_c_str
    : std::false_type {};

template< typename t >
struct is_c_str< t *,
    typename std::enable_if< std::is_same<
        typename std::decay< t >::type,
        char
    >::value >::type
>
    : std::true_type {};

The tricky part, of course, is analyzing what's inside the pointer type instead of the pointer type itself.

Answer 5

There are couple of problems.

1. The line

   !std::is_same<char *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value
   

   needs to be

   std::is_same<char *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value
   

2. Your logic of using typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value is flawed. It does not convert char const* to char*. It can convert char* const to char*.

What you need is:

template<class T>
struct is_c_str
  : std::integral_constant<
  bool,
  std::is_same<char *, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value ||
  std::is_same<char const*, typename std::remove_reference<typename std::remove_cv<T>::type>::type>::value
> {};