pass reference to array in C++

Question

Can any one help me understand the following code

#include <iostream>  void foo(const char * c) {    std::cout << "const char *" << std::endl; }  template <size_t N> void foo(const char (&t) [N]) {    std::cout << "array ref" << std::endl;    std::cout << sizeof(t) << std::endl; }  int main() {     const char t[34] = {'1'};     foo(t);      char d[34] = {'1'};     foo(d); } 

The output is

const char * array ref 34 

Why does the first foo calls the const char * version ? How can I make it call the reference version ?

Answer 1

Conversion of const char[N] to const char* is considered an "exact match" (to make literals easier, mainly), and between two exact matches a non-template function takes precedence.

You can use enable_if and is_array to force it to do what you want.

---

A messy way to force it might be:

#include <iostream>  template <typename T> void foo(const T* c) {    std::cout << "const T*" << std::endl; }  template <typename T, size_t N> void foo(const T (&t) [N]) {    std::cout << "array ref" << std::endl; }  int main() {     const char t[34] = {'1'};     foo(t);      char d[34] = {'1'};     foo(d); }  /* array ref array ref */ 

I realise that the OP had char not some generic T, but nonetheless this demonstrates that the problem lay in one overload being a template and not the other.

Answer 2

Let's look at this modified example with no template.

void foo(const char * c) {     std::cout << "const char *" << std::endl; }  void foo(const char (&t) [34]) {     std::cout << "const char (&) [34]" << std::endl; }  int main() {     const char t[34] = {'1'};     foo(t); } 

My compiler says call of overloaded foo is ambiguous. This is because conversions from array to pointer are considered an "Exact" conversion sequence and are not better than the null conversion sequence for overload resolution (Standard section 13.3.3.1.1.)

In the original code, the template parameter N can be deduced as 34, but then both non-template foo(const char*) and foo<34>(const char (&)[34]) are considered in overload resolution. Since neither is better than the other by conversion rules, the non-template function beats the template function.

Fixing things seems tricky. It seems like the is_array template from header <type_traits> (from C++0x if possible or Boost if not) might help.