Proposed resolution:

1. Change in 12.2.2.9 [over.match.class.deduct] paragraph 1.8 as follows:

   • if e_i is of array type and x_i is a braced-init-list or string-literal, T_i is an rvalue reference to the declared type of e_i, and
   • if e_i is of array type and x_i is a string-literal, T_i is an lvalue reference to the const-qualified declared type of e_i, and
   • ...

2. Append to the example in 12.2.2.9 [over.match.class.deduct] paragraph 2 as follows:

     G g(true, 'a', 1); // OK, deduces G<char, bool>
   

     template<class T, std::size_t N>
     struct H {
       T array[N];
     };
     template<class T, std::size_t N>
     struct I {
       volatile T array[N];
     };
     template<std::size_t N>
     struct J {
       unsigned char array[N];
     };
   
     H h = { "abc" };  // OK, deduces H<char, 4> (not T = const char)
     I i = { "def" };  // error: cannot bind reference to volatile-qualified type to a temporary
     J j = { "ghi" };  // OK, deduces J<4>
   

Consider:

  template<typename T, std::size_t N>
  struct A {
    T array[N];
  };

  A a = { "meow" };

The current wording says in 12.2.2.9 [over.match.class.deduct] bullet 1.8:

• if ei is of array type and xi is a braced-init-list or string-literal, Ti is an rvalue reference to the declared type of ei, and
• ...

This will fail overload resolution, because a string literal (which is an lvalue) does not match a parameter of type T (&&)[N].