Help with sizeof and pointers

[Metzen]

hello,
ok, I want to find the length of an int array that is being passed to a function:

main()
{
int array[]={1,2,3,4,5,6,7 ,8};
function(array) ;
}
function(int *array)
{
int arraylen = sizeof(*array)/sizeof(int);
}
arraylen should be 8 I get 1.

What am I doing Wrong?

Thanx

[Buster]

"Buster" <no***@nowhere. com> wrote

#define MACRO(a) (sizeof (a) / sizeof (int))

Or better,
#define MACRO(a) (sizeof (a) / sizeof * (a))

Regards.

[Duane Hebert]

> // Begin listing

#include <iostream>
#include <ostream>

#define MACRO(a) (sizeof (a) / sizeof (int))

template <typename T, unsigned N>
int function (T (&) [N]) { return N; }

int test (int a [])
{
// std::cout << function (a) << ", "; // compile-time error
std::cout << MACRO (a) << std::endl; // no error signaled
}

int main ()
{
int array [] = { 1, 2, 3, 4, 5, 6, 7, 8 };

std::cout << function (array) << ", ";
std::cout << MACRO (array) << std::endl;

test (array);
}
// End listing

I get what I expected on mingw32-g++ 3.2 and on bcb32:
the output is "8, 8"; "1". Both compilers report the compile
time error marked if I uncomment that line.

So the template version is slightly superior in that, although
it only works in a small set of situations, it will not compile
unless it can give you the correct answer.

It's probably only rarely that this can be used instead of the
techniques mentioned in the other replies, and even more
rarely that it will provide any significant advantage in speed
or code size. But maybe sometimes.

What happens if you do:
int main ()
{
short array [] = { 1, 2, 3, 4, 5, 6, 7, 8 };
std::cout << MACRO (array) << std::endl;
}

What if short was SomeLargeObect instead? Stroustrup advises against using
macros as they defeat the
type safety that C++ supplies. I would suggest that the template solution
is more than "slightly" superior in
that respect.

[Kevin Goodsell]

Big Brian wrote:

You need to pass the size into the function.

Or, if you can make some assumptions about the array, like what's the
last value in it ( like '\0' terminated c style char arrays ), you can
determine the length of the array.

True. That's sort of passing the size in implicitly. Passing a
std::vector (probably by reference) instead is another obvious solution,
which I didn't mention mostly because I was in a hurry. But that also
passes the size (implicitly) into the function. My statement is quite
true, but has to be taken in a very broad sense. Somehow, information
about where the array ends must be communicated to the function (and
it's not implicit in an "array argument" which is, in fact, not an array
at all).

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[Kevin Goodsell]

Buster wrote:

"Metzen" <an****@yahoo.c om> wrote

hello,
ok, I want to find the length of an int array that is being passed to a
function:

The following might work. I can't work out whether the standard says it does.

It absolutely will not work.

// Begin listing
#include <iostream>
#include <ostream>

#define MACRO(a) (sizeof (a) / sizeof (int))

template <typename T, unsigned N>
int function (T (&) [N]) { return N; }

int test (int a [])
The type of a is 'pointer to int'.
{
// std::cout << function (a) << ", "; // compile-time error
This didn't work because 'a' is not an array, but a pointer. You CANNOT
pass arrays to functions (directly). It always passes a pointer. Array
arguments... aren't. They are pointer arguments.
std::cout << MACRO (a) << std::endl; // no error signaled

The macro expands to

(sizeof (a) / sizeof (int))

which is equivalent to (sizeof(int*)/sizeof(int)) which does not give
the number of elements pointed to by 'a'.

I see that later you say this is the result you expected. OK, then...
but it's not an answer to the question, because it doesn't let you
determine the size of an array pointed to by a pointer argument to a
function.

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[Buster]

"Kevin Goodsell" <us************ *********@never box.com> wrote in message

Buster wrote:

The following might work. I can't work out whether the standard says it does.

It absolutely will not work.
I think we're in agreement about what does and doesn't work. What I expected
to happen, happens. What I'm not sure of is whether what I expect is enforced
by the standard.
// std::cout << function (a) << ", "; // compile-time error

This didn't work because 'a' is not an array, but a pointer. You CANNOT
pass arrays to functions (directly). It always passes a pointer. Array
arguments... aren't. They are pointer arguments.

Yes, I know.

std::cout << MACRO (a) << std::endl; // no error signaled

The macro expands to

(sizeof (a) / sizeof (int))

which is equivalent to (sizeof(int*)/sizeof(int)) which does not give
the number of elements pointed to by 'a'.

Yes, I know. I recommended the template solution and showed
the older C-style technique for comparison. It's unfortunate that
I got the macro wrong, but there you go.
I see that later you say this is the result you expected. OK, then...
but it's not an answer to the question, because it doesn't let you
determine the size of an array pointed to by a pointer argument to a
function.
The question was "I want to find the length of an int array that is being
passed to a function". No mention of pointers there.
-Kevin

[Buster]

"Duane Hebert" <sp**@flarn.com > wrote

What happens if you do:
int main ()
{
short array [] = { 1, 2, 3, 4, 5, 6, 7, 8 };
std::cout << MACRO (array) << std::endl;
}
Implementation specific. But I should have had:
#define MACRO(a) (sizeof (a) / sizeof * (a))
which works in that situation.
What if short was SomeLargeObect instead?
The new MACRO would work just fine.
Stroustrup advises against using
macros as they defeat the
type safety that C++ supplies.
Quite right too, but type safety is not the issue here.
The decay of an array into a pointer is what makes
this macro dangerous.
I would suggest that the template solution
is more than "slightly" superior in
that respect.

"Slightly" is enough for me.

Thanks,
Buster.

[Artie Gold]

Buster wrote:

"Kevin Goodsell" <us************ *********@never box.com> wrote in message

Buster wrote:

The following might work. I can't work out whether the standard says it

does.

It absolutely will not work.

I think we're in agreement about what does and doesn't work. What I expected
to happen, happens. What I'm not sure of is whether what I expect is enforced
by the standard.

// std::cout << function (a) << ", "; // compile-time error

This didn't work because 'a' is not an array, but a pointer. You CANNOT
pass arrays to functions (directly). It always passes a pointer. Array
arguments.. . aren't. They are pointer arguments.

Yes, I know.

std::cout << MACRO (a) << std::endl; // no error signaled

The macro expands to

(sizeof (a) / sizeof (int))

which is equivalent to (sizeof(int*)/sizeof(int)) which does not give
the number of elements pointed to by 'a'.

Yes, I know. I recommended the template solution and showed
the older C-style technique for comparison. It's unfortunate that
I got the macro wrong, but there you go.

I see that later you say this is the result you expected. OK, then...
but it's not an answer to the question, because it doesn't let you
determine the size of an array pointed to by a pointer argument to a
function.

The question was "I want to find the length of an int array that is being
passed to a function". No mention of pointers there.

You may be passing an array, but by the time the function you're
calling sees it, it has decayed into a pointer.

HTH,
--ag
--
Artie Gold -- Austin, Texas

[Buster]

> > The question was "I want to find the length of an int array that is being

passed to a function". No mention of pointers there.

You may be passing an array, but by the time the function you're
calling sees it, it has decayed into a pointer.

Not if you pass the array by reference.

Regards,
Buster.

[Artie Gold]

Buster wrote:

The question was "I want to find the length of an int array that is being
passed to a function". No mention of pointers there.

You may be passing an array, but by the time the function you're
calling sees it, it has decayed into a pointer.

Not if you pass the array by reference.

OK, I'm intrigued.
Example code?

Cheers,
--ag

--
Artie Gold -- Austin, Texas

[Buster]

"Artie Gold" <ar*******@aust in.rr.com> wrote

You may be passing an array, but by the time the function you're
calling sees it, it has decayed into a pointer.

Not if you pass the array by reference.

OK, I'm intrigued.
Example code?

I already posted some. Shane Beasley's post has examples too.

Yours,
Buster.