Question

Please consider this code:

template<typename T>
char (&f(T[1]))[1];

template<typename T>
char (&f(...))[2];

int main() { char c[sizeof(f<void()>(0)) == 2]; }

I expected it doing SFINAE and chosing the second overload, since substitution of T into T[1] yields

 void [1]()

Which is an invalid type, of course. Adjustment of parameter types (array->pointer) is done after substituting template parameters into function parameters and checking for valid resulting types like 14.8.2 [temp.deduct] describes.

But both comeau and GCC fail to compile the above. Both with different diagnostics.

Comeau says:

"ComeauTest.c", line 2: error: array of functions is not allowed char (&f(T[1]))[1];

GCC says (version 4.3.3):

error: ISO C++ forbids zero-size array c

Meaning, GCC does not fail to substitute, but it chooses the first overload of f, returning a sizeof of 1, instead of failing to substitute it up front like Comeau.

What compiler is right and is my code valid at all? Please refer to or quote the proper Standard section in your answer. Thanks!

---

Update: The Standard itself contains such an example in the list at 14.8.2/2. I don’t know, why I overlooked it first:

template <class T> int f(T[5]);
int I = f<int>(0);
int j = f<void>(0); // invalid array

While the example is only informative, it shows the intention of all those mysterious paragraphs and seems to show the code above should work and reject the first overload.

Answer 1

A small note, although very rare, I have found some occasions where I
believe that the Comeau compiler has it wrong – although, these
occasions are so rare that its always worth double and triple
checking your assumptions!

I may have a reason for the behaviour of g++. I’m not sure its
specified exactly when parameter types are adjusted:

Consider the following:

template<typename T>
struct A
{
  void bar (T[10]);
};

template<typename T>
void A<T>::bar (T*)
{
}

The definition of ‘bar’ is legal, as “T[10]” decays to “T*”. I do
not see anything in the standard that prohibits the compiler from
performing the adjustments of 8.3.5 against the template declaration,
and it also improves performance when it comes to overload matching.

Applying this to your example, g++ might be treating it as:

template<typename T>
char (&f( T* ))[1];

template<typename T>
char (&f(...))[2];

int main() { char c[sizeof(f<void()>(0)) == 2]; }

In the above, the substituted parameter is a legal pointer to
function, rather than an array of functions.

So, the question for me is – is if there is something that prohibts
the adjustments for the function parameters (8.3.5) twice?

Personally, I think it makes sense to allow the adjustments to happen
twice since otherwise it complicates the matching of function template
overloads

In conclusion, I think its valid for g++ to select the first overload
based on how it treates decaying array parameters, and Comeau is wrong
not to have a deduction failure for the array of functions.

Of course this now means that (if Comeau was fixed) then each compiler
would choose a different overload and would still be standards
compliant! 🙁

EDIT:

Just to illustrate my point, consider the following code:

template <typename T> void foo ( T * );
template <typename T> void foo ( T * const );
template <typename T> void foo ( T [] );
template <typename T> void foo ( T [10] );
template <typename T> void foo ( T [100] );

void bar () 
{
  foo < void() > ( 0 );
}

Here, foo has been declared and redeclared several times. Which declaration, and so which parameter type, should the compiler apply the rules listed in 14.8.2?

My point is that the standard doesn’t say anything about the above. I would also go as far as to say that any wording on this would have to leave it as either “undefined” or “implementation defined” behaviour.