What's wrong with 'template< unsigned N, unsigned M> int compare(char p1 [N], char p2 [M])'

Question

while I came across this snippet in <<C++ Primer>>

template< unsigned N, unsigned M>
int compare(const char(&p1)[N], const char (&p2)[M]
{
    return strcmp(p1, p2);
}
compare("hi", "mom")

sure it worked very well then i thought what if if remove const and & ? so i wrote this

template< unsigned N, unsigned M>
int compare(char p1 [N], char p2 [M])
{
    return strcmp(p1, p2);
}
compare("hi", "mom")

but i got this error

prog.cc: In function 'int main()':
prog.cc:34:12: error: no matching function for call to 'compare(const char [3], const char [4])'
   34 |     compare("hi", "mom");
      |     ~~~~~~~^~~~~~~~~~~~~
prog.cc:27:5: note: candidate: 'template<unsigned int N, unsigned int M> int compare(char*, char*)'
   27 | int compare(char p1 [N], char p2 [M])
      |     ^~~~~~~
prog.cc:27:5: note:   template argument deduction/substitution failed:
prog.cc:34:12: note:   couldn't deduce template parameter 'N'
   34 |     compare("hi", "mom");
      |     ~~~~~~~^~~~~~~~~~~~~

Why doesn't this work?

Answer 1

Neither in C nor in C++ there exists a straight-forward manner to pass a C-style array by value (see e.g. here). A C-style array - if not wrapped by a class or struct - is actually only passed as a pointer. This also leads to problems with template deduction as a pass by value decays to a simple pointer and therefore the compiler can't deduce the template argument. Therefore the common approach is to either pass it by const or non-const reference or to switch to an std::array if a copy is needed. I don't think the second version of your template actually does what you want it to do.

---

Your initial code

template <unsigned N, unsigned M>
int compare(char const (&p1)[N], char const (&p2)[M]) {
  return std::strcmp(p1, p2);
}

is working fine. A reference to an array does not decay to a pointer: Therefore when calling the template with compare("hi", "mom") the compiler is able to deduce N to 3 and Mto 4 (+1 because it is null-terminated).

• As soon as you remove the constant but keep the reference

  template <unsigned N, unsigned M>
  int compare(char (&p1)[N], char (&p2)[M]) {
    return std::strcmp(p1, p2);
  }
  

  the code will stop compiling if called with something like compare("hi", "mom") as they are string literals, which are constant lvalues, and therefore can't be passed to non-constant references but it would still work if the two variables are not string literals but instead regular variables.

• If you remove the reference keeping the constant

  template <unsigned N, unsigned M>
  int compare(char const p1[N], char const p2[M]) {
    return std::strcmp(p1, p2);
  }
  

  the compiler will not be able to deduct the template arguments M and N anymore as the argument will decay to a pointer. As soon as you tell it which version to use compare<3,4>("hi", "mom"); or add two other arguments for the length of the arrays it will compile fine but be aware - you are actually not creating a copy of the array but instead you are only using a constant pointer which might seem unexpected.

• Now when removing both - const as well as the reference -

  template <unsigned N, unsigned M>
  int compare(char p1[N], char p2[M]) {
    return std::strcmp(p1, p2);
  }
  

  then again the compiler won't be able to deduct the template arguments. If you then tell it explicitly which template arguments to use it might still compile depending on the compiler (GCC for example will issue a warning but in case you activate -pedantic-errors the program will terminate with an error). So to comply with the C++ standard you should not give it any string literals or temporary values as input arguments as well. Again this behaves now contrary to what you might expect: Modifying the values of p1 and p2 inside your function will actually change the ones inside your calling function! Therefore I would not advise you to use this syntax at all - it is very misleading.

---

There area a couple of options for avoiding this mess altogether:

• You could pass the array by reference and then create your local copy manually.

• You could wrap it with a struct. This will automatically create a copy of the wrapped C-style array.

• You could use an std::array<char,N> instead which can be passed by value like a regular variable. When using it with std::strcmp - like in your case - you would though actually have to copy the data into another C-style array though.

• You could pass an std::string as input argument and only then convert it to a char array for std::strcmp

  int compare(std::string const& p1, std::string const& p2) {
    return std::strcmp(p1.c_str(), p2.c_str());
  }
  

  or use the std::string comparison operator instead as well

  int compare(std::string const& p1, std::string const& p2) {
    return (p1 == p2);
  }
  

  This allows you to get rid of the template completely.