Whats the difference between reference to an array and array as a parameters in functions?

Question

What is the difference between functions, which have reference to an array:

// reference to array
void f_(char (&t)[5]) {
    auto t2 = t;
}

and simply array:

// just array
void f__(char t[5]) {
    auto t2 = t;
}

as a parameters?

The calling code is:

char cArray[] = "TEST";
f_(cArray);
f__(cArray);

char (&rcArr)[5] = cArray;
f_(rcArr);
f__(rcArr);

In both cases t2 is char*, but in first function my VS2019 is showing that t inside function has type char(&t)[] and t inside second function has type char*.

So after all, is there any practical difference between those functions?

Try to pass an array as argument to both your functions, and see the first one fail. (The second actually takes a pointer, not an array.) — molbdnilo
– molbdnilo, Commented Dec 17, 2021 at 18:26
The second still takes a pointer; when there's no reference, the size is ignored. — molbdnilo
– molbdnilo, Commented Dec 17, 2021 at 18:37
The second does not, in fact, take an exact sized array. It takes a pointer. Try it! — Pete Becker
– Pete Becker, Commented Dec 17, 2021 at 20:06
This doesn't address the question, but names that contain two consecutive underscores (f__) and names that begin with an underscore followed by a capital letter are reserved for use by the implementation. Don't use them in your code. — Pete Becker
– Pete Becker, Commented Dec 17, 2021 at 20:08

Vlad from Moscow · Accepted Answer · 2021-12-17 19:25:34Z

2

You can specify a complete array type parameter as for example

void f( int ( &a )[N] );

and within the function you will know the number of elements in the passed array.

When the function is declared like

void f( int a[] );

then the compiler adjusts the function declaration like

void f( int *a );

and you are unable to determine the number of elements in the passed array. So you need to specify a second parameter like

void f( int *a, size_t n );

Also functions with a referenced array parameter type may be overloaded. For example these two declarations

void f( int ( &a )[] );

and

void f( int ( &a )[2] );

declare two different functions.

And functions with a referenced array parameter type may be called with a braced list (provided that the corresponding parameter has the qualifier const) like for example

f( { 1, 2, 3 } );

Here is a demonstration program

#include <iostream>

void f( const int ( &a )[] )
{
    std::cout << "void f( const int ( & )[] ) called.\n";
}

void f( const int ( &a )[2] )
{
    std::cout << "void f( const int ( & )[2] ) called.\n";
}

void f( const int a[] )
{
    std::cout << "void f( const int [] ) called.\n";
}


int main()
{
    f( { 1, 2, 3 } );
}

The program output is

void f( const int ( & )[] ) called.

edited Dec 17, 2021 at 19:25

answered Dec 17, 2021 at 18:36

Vlad from Moscow

313k27 gold badges204 silver badges358 bronze badges

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

8 Comments

hgrev Over a year ago

thanks, but first example wont compile. you need to specify size_t parameter like that: template<size_t N> void f(int (&a)[N]) {};

Vlad from Moscow Over a year ago

@hgrev I did not mean a template function. I mean non-tempalte functions. N is some constant expression or an absence of it.

hgrev Over a year ago

yes, i mean non-template function too, but it wont compile until you specify N

Vlad from Moscow Over a year ago

@hgrev It seems you are using an old compiler or a compiler that contains a bug. See my updated post. You can try the program at www.godbolt.org

Vlad from Moscow Over a year ago

@hgrev If the number of elements in the parameter is specified as for example void f( int ( &a )[10] ); then you will know the number.:) You can apply the operator sizeof to the parameter and you will get the exact size of the array. When the parameter has not a referenced type when even you will specify void f( int a[10] ); the compiler will adjust the function declaration like void f( int *a ); That is you will deal with a pointer.

|

Chris Dodd · Accepted Answer · 2021-12-17 20:00:40Z

0

Since you cannot pass arrays by value (a C restriction that C++ inherits) any declaration of a parameter as an array will 'decay' into a pointer (losing its size). So the declaration

void f__(char t[5])

is identical to

void f__(char *t)

Everything else follows from this -- within the body of f__, t has a pointer type, NOT an array type. So any auto inferencing from it will be based on that pointer type.

answered Dec 17, 2021 at 20:00

Chris Dodd

127k14 gold badges150 silver badges243 bronze badges

Collectives™ on Stack Overflow

Whats the difference between reference to an array and array as a parameters in functions?

2 Answers 2

8 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

8 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related