SFINAE with invalid function-type or array-type parameters?

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 dunno 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

Suprisingly enough - this does work in VS2008. I don't think that's necessarily evidence for it being correct behaviour or not though...

Visual Studio is interpretting

char (&f(T[1]))[1];

as a function that takes an array of size 1 of T, and returns a reference to an array of chars of size 1.

Answer 2

I'll try to describe the process of template argument deduction as I understand it from reading the standard.

1. Explicit template arguments are checked as described in 14.8.2/2.
2. The resulting function signature is adjusted as per 8.3.5 (i.e. array to pointer decay is performed).
3. Implicit template arguments are deduced as per 14.8.2.1 (this is performed on a partially substituted signature from step 2).

The deduction for the first overload fails in step 1, the overload resolution therefore returns the second overload. I don't believe the program is ill-formed.

Answer 3

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.