Template Argument Deduction from String Literal - c++

Question

I am currently thinking about how to best constrain a generic type of a template to an std::sting as well as string literals. Therefore I compare the deduced type with the desired type using std::is_same. In case of an std::string this works right away. For a string literal, meaning a char const array, it only works if I use std::decay on the type and then compare the result to the type char const *. If I directly compare the deduced type to what I think it should be, is_same returns false, as is illustrated by the following example code.
template <class TYPE>
void function(TYPE&& parameter)
{
//this doesn't work as expected
std::cout << typeid(TYPE).name() << " : " << typeid(char const [5]).name() << std::endl;
std::cout << std::is_same<char const [5], TYPE>::value << std::endl;
//this works as expected
std::cout << typeid(std::decay_t<TYPE>).name() << " : " << typeid(char const *).name() << std::endl;
std::cout << std::is_same<char const *, std::decay_t<TYPE>>::value << std::endl;
}
int main(int argc, char** argv)
{
function("name");
return 0;
}
The output generated is the following:
char const [5] : char const [5]
0
char const * __ptr64 : char const * __ptr64
1
Now, what I am wondering is why is_same returns false in the first case even though the types appear to be identical.
The only possible explanation that I could come up with is that within the function std::is_same a transformation similar to std::decay is applied to the type (for instance a function call). But then again this transformation would also occur to the other type, yielding the same result and thus resulting in equality.

Answer 1

String literals are not passed by value as char const [N], but by reference as char const (&)[N].
This works correctly for me:
std::cout << std::is_same<char const (&)[5], TYPE>::value << std::endl;
Note here that
1) Refers to a std::type_info object representing the type type. If type is a reference type, the result refers to a std::type_info object representing the referenced type.
You can easily verify that is_same doesn't discard reference-ness in the same way as type_info, for example by checking that
std::is_same<int&, int>::value == false
This explains why the typeid name is the same, but your is_same test still fails.

Answer 2

Using gcc custom function:
template < class T >
constexpr std::string type_name()
{
std::string p = __PRETTY_FUNCTION__;
return p.substr( 43 + 10, p.length() - 100 - 1 - 10 );
}
And adding it to your code:
std::cout << type_name<TYPE>() << " : " << type_name<char const [5]>() << std::endl;
The results are:
A5_c : A5_c
0
const char (&)[5] : const char [5]
So you need to use std::remove_reference on TYPE.

Answer 3

It may be an mistake of the compiler. The compiler generates such types-objects given by typeid at compiletime. The compiler wouldn't compile array-types for each length (0 to 2**n), so it compiles them when needed, and it may "forget" about the duplicate. Try to use a special template where you seperate the length from the contained type. This is not the type but you can check if it is equal to another.
template<class T, size_t size>
struct array_t{};
template <class T, size_t size>
void function(T[size] parameter) {
std::cout << typeid(array_t<T, size>).name() << " : " << typeid(array_t<char, 5>).name() << std::endl;
std::cout << std::is_same<array_t<T, size>, array_t<char, 5>>::value << std::endl;
};