Template argument deduction of string literal - c++

Question

Consider this simple function
template<typename T>
void func(const T& x) {std::cout<< typeid(T).name();}
now if I call function func("ddd") , what does T deduces to? . If there were no const in func's parameter , T would be simply char [4] , Whats confusing me is addition of const , what does T deduces to ?
is it : const char [4] . If I change the parameter to T const &x (i.e change order of const) does deduction produces T to char const [4] ?
Can anyone explain argument deduction with string literals?

Answer 1

String literals are arrays of const characters.
A reference to string literal of 4 chars is of type char const (&)[4].
const char [4] and char const [4] are same types!
char const (&)[N], const char [N] and char const [N] all deduce to char const [N]
#include <iostream>
template<typename T>
void func1(T& x) {std::cout<< typeid(T).name()<<std::endl;}
template<typename T>
void func2(const T& x) {std::cout<< typeid(T).name()<<std::endl;}
template<typename T>
void func3(T const &x) {std::cout<< typeid(T).name()<<std::endl;}
int main()
{
char c[4]= {'a','b','c','d'};
const char c1[4]= {'a','b','c','d'};
char const c2[4]= {'a','b','c','d'};
func1("abcd"); //prints char const [4]
func1(c); //prints char [4]
func1(c1); //prints char const [4]
func1(c2); //prints char const [4]
func2("abcd"); //prints char const [4]
func2(c); //prints char [4]
func2(c1); //prints char const [4]
func2(c2); //prints char const [4]
func3("abcd"); //prints char const [4]
func3(c); //prints char [4]
func3(c1); //prints char const [4]
func3(c2); //prints char const [4]
return 0;
}

Answer 2

const usually refers to whatever is in front of it:
char const * -- pointer to constant char
char * const -- constant pointer to char
char const * const -- constant pointer to constant char
char Foo::bar() const -- constant member function returning char
etc.
The leading const is an exception dating back to the early days of C:
const char * <=> char const *
So, changing the ordering in your template would not change the type at all (T const & <=> const T &).
If you want to be consistent about const placement, use the trailing type exclusively, because it's the only way you can place const consistently.

Answer 3

now if I call function func() , what does T deduces to?
If you call with a string literal, then T deduces to char const[N].
If there were no const in func's parameter , T would be simply char [4]
If you mean that if you declared the parameter as T& x, then no: T would still be deduced to char const[N] if you call with a string literal.
If you mean that you call func with a non-const array, then yes: T would be deduced non-const.
If I change the parameter to T const &x
That changes nothing because const T & is just another way of writing T const &.