Passing C array to static function declared within a class scope

Question

Why in the following example the compiler fails to bind the very same static function if it's declared within a class scope?

#include <vector>
#include <iostream>

struct Foo
{
static constexpr int GetSize()
{
    return 5;
}
static void ProcessArrayWrong(int(&indices)[Foo::GetSize()])
{
    for(int i =0; i < Foo::GetSize(); i++)
    {
        indices[i]++;
    }
}
};

static void ProcessArray(int(&indices)[Foo::GetSize()])
{
    for(int i =0; i < Foo::GetSize(); i++)
    {
        indices[i]++;
    }
}

int main(int argc, char* argv[])
{
    int foo[Foo::GetSize()] = {1,2,3,4,5};

    for(int i =0; i < Foo::GetSize(); i++)
    {
        std::cout << foo[i]++ << std::endl; 
    }
    ProcessArray(foo);
    ProcessArrayWrong(foo); // fails here
    for(int i =0; i < Foo::GetSize(); i++)
    {
        std::cout << foo[i]++ << std::endl; 
    }
    return 0;
}

The error is:

error: non-const lvalue reference to type 'int [*]' cannot bind to a value of unrelated type 'int

It seems that the question linked in the comments is explaining why it's an error. Thanks. It'd be great to know at this point, in regards with the answers provided in the linked post:

Why exactly the "template trick" works? I suspect because template code requires an additional pass to be compiled, but I would rather have a more clear opinion on this.
Is declaring the function has template causing any non wanted or non expected behavior or is it safe to use?

The "template trick" is required because int(&indices)[Foo::GetSize()] is an incomplete type, a reference to an array of "who knows how big" at compile-time. — David C. Rankin
– David C. Rankin, Commented Mar 30, 2020 at 16:16
Thanks, I see. Is it safe to use that? or is there any non obvious downside? — Heisenbug
– Heisenbug, Commented Mar 30, 2020 at 16:19

Davis Herring · Accepted Answer · 2020-03-30 17:33:03Z

1

The “template trick” works because templates (and member functions of class templates) are already instantiated on-demand. While the standard doesn’t actually say that that property allows member functions to be used in things like array sizes, neither is there any actual rule against it in the non-template case and common implementation strategies support the trick as a side benefit.

Given that the current opinion is that the (class) template behavior is more correct, it’s probably safe to rely on it. Moreover, the standard library declares all sorts of things as templates invisibly, indicating that it generally doesn’t cause problems. (You can even use things like explicit instantiations to keep the function template’s definition elsewhere.)

answered Mar 30, 2020 at 17:33

Davis Herring

41.9k4 gold badges58 silver badges91 bronze badges

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

Collectives™ on Stack Overflow

Passing C array to static function declared within a class scope

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related