https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114812
Bug ID: 114812
Summary: Arguments of array type decay to pointer type too
eagerly when used as arguments to ref- or
ptr-to-function
Product: gcc
Version: 13.2.1
Status: UNCONFIRMED
Severity: normal
Priority: P3
Component: c++
Assignee: unassigned at gcc dot gnu.org
Reporter: rkraesig at mozilla dot com
Target Milestone: ---
In a function-call expression, if the value F invoked as a function is of type
reference-to-function or pointer-to-function, a value of reference-to-array
type passed as an argument to F appears to be immediately converted to the
corresponding pointer type to which it would decay.
This prevents implicit converting constructors for the nominal argument types
of F which would convert from reference-to-array from being found.
This does not occur if F is of function type, nor if it is of some object type
with an `operator()`; in these cases the array type is passed without decay.
Example code (also at https://godbolt.org/z/jjKE31G7r):
struct S {
S(const int (&)[2]) {}
// S(const int *) {} // footnote [0]
};
static const int arr[] = {17, 42};
void func(S s) {}
void test() {
void (&f)(S) = func;
f(arr); // fails on GCC; succeeds on clang & MSVC
// func(arr); // succeeds everywhere
// (std::function{f})(arr); // succeeds everywhere
}
[0] If this alternate constructor is uncommented, the above code will compile
successfully under GCC... but will fail to compile on clang and MSVC, which
reject `f(arr);` as ambiguous.
Per testing on godbolt, this is not a recent regression, but appears to happen
on every version of GCC back to at least 4.1.2.
