It is necessary to determine the size of the array passed to the function. Tried like this:
void foo (int * Array)
{
const unsigned int SIZE = sizeof (Array) / sizeof (int);
}
but SIZE
retains 1, regardless of the size of the array. You can, of course, pass the size to the function along with the array, but maybe there is a more elegant solution?
P.S .: By the way, I noticed something strange. Launched this program through Visual Studio and Qt. In VS, SIZE
stores 1, while in Qt 2.
Answer 1, authority 100%
You have a function parameter foo
declared as a pointer of type int *
void foo (int * Array);
^^^^^^^^^^
Hence, inside the function, the expression
sizeof (Array) / sizeof (int)
is equivalent to
sizeof (int *) / sizeof (int)
If, for example, the size of a pointer, that is, of type int *
, is 8 bytes, and the size of type int
is 4 bytes, then you will end up with 2. If while the size of the int
type is also 8 bytes (64-bit OS), you will end up with 1.
But even if you declare this function as
void foo (int Array []);
or even so
void foo (int Array [10]);
anyway, the function parameter is implicitly converted to a pointer to an array element. That is, these two function declarations declare the same function and are equivalent to the following declaration
void foo (int * Array);
So inside the function, you will be dealing with a pointer again.
When passing an array by value, you should also declare a second parameter that specifies the size of the array.
Or the array must have some boundary element with a unique value, which can be used to determine the number of actual elements, as is the case, for example, with strings, when strings are null terminated, that is, the character '\ 0'
.
That is, in general, you should declare a function as
void foo (int * Array, size_t n);
where n
is the size of the array.
Another approach is to declare the parameter as an array reference. In this case, the length of the array will be known inside the function. For example
void foo (int (& amp; Array) [10])
{
const size_t = sizeof (Array) / sizeof (* Array);
}
The disadvantage of this declaration is that this function can only deal with arrays given in its size parameter.
To work around this limitation, you can declare a templated function. For example,
template & lt; size_t N & gt;
void foo (int (& amp; Array) [N])
{
const size_t n = N;
}
In this case, the compiler, using the template, will create as many functions as arrays of different lengths were used as an argument.