Can I forward an array type to a function invoked via pointer perfectly, without the argument decaying?

Question

I have an issue that boils down to an example like this:

#include <cstdlib>
#include <utility>

// class that is constructible from a `float` array type
struct data
{
    template <size_t N>
    data(float (&arr)[N]) { }
};

// function that takes an instance of `data`
void direct(data) { }
// pointer to the above function
void (*func_ptr)(data) = &direct;

// forward the argument to the function directly
template <typename T>
void call_direct(T && t)
{
    return direct(std::forward<T>(t));
}

// forward the argument to the function invoked via pointer
template <typename T>
void call_via_ptr(T && t)
{
    return (*func_ptr)(std::forward<T>(t));
}

int main()
{
    float arr[4];

    call_direct(arr);
    call_via_ptr(arr);
}

That is, I have a function direct() that takes an argument of type data. data is constructible from a fixed-length C style array. I have another pair of functions, call_direct() and call_via_ptr(), which forward their single template argument to the function, either invoking it directly or via a function pointer.

The call_direct() approach works fine. However, the call_via_ptr() fails to compile on gcc versions through 14.2, yielding an error like:

<source>: In instantiation of 'void call_via_ptr(T&&) [with T = float (&)[4]]':
<source>:35:17:   required from here
   35 |     call_via_ptr(arr);
      |     ~~~~~~~~~~~~^~~~~
<source>:27:39: error: could not convert '(float*)std::forward<float (&)[4]>((* & t))' from 'float*' to 'data'
   27 |     return (*func_ptr)(std::forward<T>(t));
      |                        ~~~~~~~~~~~~~~~^~~
      |                                       |
      |                                       float*

However, it does compile fine on all clang versions that I have tried.

It looks like when calling the function via a function pointer, the array argument is decaying to a float *, which is not convertible to data, hence the error. However, it isn't clear to me why the pointer decay would work differently between the two cases.

Is there a tweak I can make here to allow this to build on gcc? Which compiler is correct here?

Out of curiosity, what happens if you use a C++ array (std::array) instead of a C-style array? — Eljay
– Eljay, Commented Mar 3 at 15:06
std::array (or any other C++ object type) works fine, which makes sense as the issue seems to be array-to-pointer decay. — Jason R
– Jason R, Commented Mar 3 at 15:09
Another data point: (*func_ptr)(data{std::forward<T>(t)}); works for g++-14 -std=c++17. — Eljay
– Eljay, Commented Mar 3 at 15:15
Even removing template part, and just call func_ptr(arr) fails :-/ Demo — Jarod42
– Jarod42, Commented Mar 3 at 15:39

AndyG · Accepted Answer · 2025-03-03 16:57:38Z

3

This is a documented bug in GCC. That is to say that clang (and msvc) are correct.

Here is the "meta-bug" covering a few variations on it. Like this which applies even when there is no template.

clang is correct because zero standard conversions should be required to match the target function.

answered Mar 3 at 16:57

AndyG

41.4k8 gold badges122 silver badges155 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Can I forward an array type to a function invoked via pointer perfectly, without the argument decaying?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related