What is useful about a reference-to-array parameter?

by

The reference-to-array parameter does not allow array type to decay to pointer type. i.e. the exact array type remains preserved inside the function. (For example, you can use the sizeof arr / sizeof *arr trick on the parameter and get the element count). The compiler will also perform type checking in order to make sure the array argument type is exactly the same as the array parameter type, i.e. if the parameter is declared as a array of 10 ints, the argument is required to be an array of exactly 10 ints and nothing else.

In fact, in situations when the array size is fixed at compile-time, using a reference-to-array (or pointer-to-array) parameter declarations can be preceived as the primary, preferred way to pass an array. The other variant (when the array type is allowed to decay to pointer type) are reserved for situations when it is necessary to pass arrays of run-time size.

For example, the correct way to pass an array of compile-time size to a function is

void foo(int (&arr)[10]); // reference to an array

or

void foo(int (*arr)[10]); // pointer to an array

An arguably incorrect way would be to use a “decayed” approach

void foo(int arr[]); // pointer to an element
// Bad practice!!!

The “decayed” approach should be normally reserved for arrays of run-time size and is normally accompanied by the actual size of the array in a separate parameter

void foo(int arr[], unsigned n); // pointer to an element
// Passing a run-time sized array

In other words, there’s really no “why” question when it comes to reference-to-array (or pointer-to-array) passing. You are supposed to use this method naturally, by default, whenever you can, if the array size is fixed at compile-time. The “why” question should really arise when you use the “decayed” method of array passing. The “decayed” method is only supposed to be used as a specialized trick for passing arrays of run-time size.

The above is basically a direct consequence of a more generic principle. When you have a “heavy” object of type T, you normally pass it either by pointer T * or by reference T &. Arrays are no exception from this general principle. They have no reason to be.

Keep in mind though that in practice it is often makes sense to write functions that work with arrays of run-time size, especially when it comes to generic, library-level functions. Such functions are more versatile. That means that often there’s a good reason to use the “decayed” approach in real life code, Nevertheless, this does not excuse the author of the code from recognizing the situations when the array size is known at compile time and using the reference-to-array method accordingly.

More Related Contents:

  1. C++ pass an array by reference
  2. sizeof works unusual at c++ after array creation [duplicate]
  3. Why is sizeof giving incorrect number of bytes in C++?
  4. How do I compare chars (or strings) using void functions, also comparing chars that were taken from a struct array
  5. C++ – Find numbers between first and last negative numbers in Array
  6. If statement – C++
  7. Accessing an array out of bounds gives no error, why?
  8. Passing a 2D array to a C++ function
  9. Pass by Reference / Value in C++
  10. Is std::vector so much slower than plain arrays?
  11. Why does cout print char arrays differently from other arrays?
  12. Default value to a parameter while passing by reference in C++
  13. Address of an array
  14. Why does pointer decay take priority over a deduced template?
  15. Sort a 2D array in C++ using built in functions(or any other method)?
  16. How to initialize std::array elegantly if T is not default constructible?
  17. May I take the address of the one-past-the-end element of an array? [duplicate]
  18. How to initialize a vector in C++ [duplicate]
  19. Is there a function to copy an array in C/C++?
  20. How do I initialize a member array with an initializer_list?
  21. Structure of Arrays vs Array of Structures
  22. How to get the real and total length of char * (char array)?
  23. How to initialize 3D array in C++
  24. How can I use an array as map value?
  25. C++ : Creating an array with a size entered by the user
  26. How to return array from C++ function to Python using ctypes
  27. C++: Why pass-by-value is generally more efficient than pass-by-reference for built-in (i.e., C-like) types
  28. array of pointers as function parameter
  29. C / C++ How to copy a multidimensional char array without nested loops?
  30. Polymorphism & Pointers to arrays [duplicate]

Leave a Comment