is this allowed to pass an array by reference ?
void foo(double& *bar)
Seems that my compiler says no. Why? What is the proper way to pass an array by reference? Or a work around? I have an array argument that my method should modify and that I should retrieve afterwards. Alternatively, I could make this array a class member, which works fine, but it has many drawbacks for other part of my code (that I would like to avoid).
Thanks and regards.
Arrays can only be passed by reference, actually:
void foo(double (&bar)[10])
{
}
This prevents you from doing things like:
double arr[20];
foo(arr); // won't compile
To be able to pass an arbitrary size array to foo, make it a template and capture the size of the array at compile time:
template<typename T, size_t N>
void foo(T (&bar)[N])
{
// use N here
}
You should seriously consider using std::vector, or if you have a compiler that supports c++11, std::array.
foo, the array decays to pointer". No it doesn't, and since you can only pass an array of 10 elements, you don't need further information about the size. (And once again, you cannot pass an array to void foo( double*& ); the results of an implicit conversion is an rvalue, and cannot be used to initialize a reference to non-const. You must use void foo( double *const & );.
void foo(T &bar[N]) in my template - but that actually means "an array of references" and not "reference to array".
std::vector (of the correct size), how would you cast the contents of the vector (perhaps obtained via std::vector::data()) to this array type? What's the syntax for a fixed array size in a type parameter (i.e. to use with static_cast<>)?
reinterpret_cast for treating a dynamically allocated array (with no intrinsic size after allocation) as an automatic one with fixed size. Besides, that's the wrong question: the right question would be 'How can I refactor my code to work with both types of container?', and the answer is templates and iterators/ranges, or since you said the size is fixed, a function that takes only a data pointer/ref and hard-codes the size (or if size could vary, a data/size adaptor like span)
Yes, but when argument matching for a reference, the implicit array to pointer isn't automatic, so you need something like:
void foo( double (&array)[42] );
or
void foo( double (&array)[] );
Be aware, however, that when matching, double [42] and double [] are
distinct types. If you have an array of an unknown dimension, it will
match the second, but not the first, and if you have an array with 42
elements, it will match the first but not the second. (The latter is,
IMHO, very counter-intuitive.)
In the second case, you'll also have to pass the dimension, since there's no way to recover it once you're inside the function.
double [] and double [42] are two different types. So the only thing you could pass to the latter form would be an array of unknown length, e.g. extern double d[];, or some such. Which seriously limits the usability.)
As you are using C++, the obligatory suggestion that's still missing here, is to use std::vector<double>.
You can easily pass it by reference:
void foo(std::vector<double>& bar) {}
Also have a look at std::array if the size of the array is known and static.
With C++20 support, also consider to wrap and pass the data as a std::span. Note that there might be some peculiarities to be aware of when it comes to constness.
For reference:
std::vector is usually the best solution. But there are exceptions.
If you want to modify just the elements:
void foo(double *bar);
is enough.
If you want to modify the address to (e.g.: realloc), but it doesn't work for arrays:
void foo(double *&bar);
is the correct form.
Here, Erik explains every way pass an array by reference: https://stackoverflow.com/a/5724184/5090928.
Similarly, you can create an array reference variable like so:
int arr1[] = {1, 2, 3, 4, 5};
int(&arr2)[5] = arr1;
Like the other answer says, put the & after the *.
This brings up an interesting point that can be confusing sometimes: types should be read from right to left. For example, this is (starting from the rightmost *) a pointer to a constant pointer to an int.
int * const *x;
What you wrote would therefore be a pointer to a reference, which is not possible.
8.3.5.8 If the type of a parameter includes a type of the form “pointer to array of unknown bound of T” or “reference to array of unknown bound of T,” the program is ill-formed
std::vectoror similar?std::vectoris obviously superior if the size is dynamic/unknown, but in cases where the size is always the same, it would be overkill, and insteadstd::arrayresolves the syntactic ugliness while also conferring value semantics.