Is there any difference between the below two functions test1 and test2
static int const MAXL = 3;
void test1(int t[MAXL])
{
for (int i = 0; i < MAXL; ++i)
t[i] = 10;
}
void test2(int (&t)[MAXL])
{
for (int i = 0; i < MAXL; ++i)
t[i] = 10;
}
With my testing in MSVC2008, both functions modifies the input array values. It seems both the functions are same in their functionality.
Can anyone give a case that need a reference to array in a function parameter?
The first one decays to a pointer to the first element in the array, the second is an actual reference to the array.
They're different in the same way that pointers and references are generally different.
Specifically, in the case of arrays, a reference to the array is useful because you retain the ability to determine the size of the array. This frees you from having to pass the size/length of the array as a separate parameter as you would in a C API.
One way of implementing this that I think is particularly slick involves templates. Using a template parameter, you can get the compiler to automatically deduce the size of the array. For example:
void ProcessArray(int* pArray, std::size length)
{
for (std::size_t i = 0; i < length; ++i)
{
// do something with each element in array
}
}
template <std::size_t N>
void ProcessArray(int (&array)[N])
{
ProcessArray(array, N); // (dispatch to non-template function)
}
sizeof operator will return only the size of the pointer. If you pass a reference to the array, you can still determine its size using the sizeof operator inside of the function.
ProcessArray call a non-templated support function ala ProcessArrayImpl(array, N); where ProcessArrayImpl takes (int*, size_t) - i.e. layering the two approaches from the question.