What does the expression "sizeof(int )*p" mean?

[Roy Yao]

Does it mean "(sizeof(in t))* (p)" or "sizeof( (int)(*p) )" ?

According to my analysis, operator sizeof, (type) and * have the same
precedence, and they combine from right to left. Then this expression should
equal to "sizeof( (int)(*p) )", but the compiler does NOT think so. Why?

Can anyone help me? Thanks.

Best regards.
Roy

[Y. Keerthi Sagar]

"Roy Yao" <fl***@263.ne t> wrote in message news:<bk******* ****@mail.cn99. com>...

Does it mean "(sizeof(in t))* (p)" or "sizeof( (int)(*p) )" ?

According to my analysis, operator sizeof, (type) and * have the same
precedence, and they combine from right to left. Then this expression should
equal to "sizeof( (int)(*p) )", but the compiler does NOT think so. Why?

Can anyone help me? Thanks.

Best regards.
Roy

Hey,
Both "(sizeof(in t))* (p)" or "sizeof( (int)(*p) )" are not same.
"(sizeof(in t))* (p)" means you are multiplying sizeof(int), i.e. 2
(bytes), with the value of "p". Whereas "sizeof( (int)(*p) )" means,
First you are getting the value of at the adderess p (because *p gives
the value of another variable), then you are converting the returned
value into interger format and finally you are detecting the size of
that result. If you have any doubts contact at my ID
ke***********@y ahoo.co.in.

Be Cool,
Y. Keerthi
Sagar & Ashok.

[Roy Yao]

Hello Keerthi,

Thanks for your enthusiasm.

My email to you was rejected by your mail server, so I reply you here.

In this expression, what confused me is how the compilers (or ANSI C)
determine the combination of operator sizeof, (type) and *.

In my opion it should equal to expression "sizeof( (int)(*p) )". The
reason is that operator sizeof, (type) and * have the same
precedence, and they combine from right to left. But the compilers prefer
"(sizeof(in t))* (p)".

Now can you give me a convictive explain from the precedence and
combination order of operator ?

Thanks again.

Best regards,
Roy Yao

[Josh Sebastian]

On Tue, 16 Sep 2003 08:44:02 +0800, Roy Yao wrote:

Hello Keerthi,

Thanks for your enthusiasm.

My email to you was rejected by your mail server, so I reply you here.

In this expression, what confused me is how the compilers (or ANSI C)
determine the combination of operator sizeof, (type) and *.

In my opion it should equal to expression "sizeof( (int)(*p) )". The
reason is that operator sizeof, (type) and * have the same
precedence, and they combine from right to left. But the compilers prefer
"(sizeof(in t))* (p)".

Now can you give me a convictive explain from the precedence and
combination order of operator ?

I told you in my other post, that's NOT the (type) operator! (type) is the
/operand/ of sizeof.

Josh

[wang tianxing]

On Mon, 15 Sep 2003 22:00:09 -0400, Josh Sebastian <cu****@cox.net >
wrote:

: On Tue, 16 Sep 2003 08:44:02 +0800, Roy Yao wrote:
:
: > Hello Keerthi,
: >
: > Thanks for your enthusiasm.
: >
: > My email to you was rejected by your mail server, so I reply you here.

You(Roy) are supposed to reply here.

: > In this expression, what confused me is how the compilers (or ANSI C)
: > determine the combination of operator sizeof, (type) and *.
: >
: > In my opion it should equal to expression "sizeof( (int)(*p) )". The
: > reason is that operator sizeof, (type) and * have the same
: > precedence, and they combine from right to left. But the compilers prefer
: > "(sizeof(in t))* (p)".
: >
: > Now can you give me a convictive explain from the precedence and
: > combination order of operator ?
:
: I told you in my other post, that's NOT the (type) operator! (type) is the
: /operand/ of sizeof.

You are right, but he wants to know why. :)

Some relevent production rules:

unary-expression:
postfix-expression
++ cast-expression
-- cast-expression
unary-operator cast-expression
sizeof unary-expression
sizeof ( type-id )
new-expression
delete-expression

unary-operator: one of
* & + - ! ~

The expression in question:

sizeof (int) * p

'(int) * p' isn't a unary-expression, because it is not starting
with ++, --, *, &, +, -, !, ~, sizeof, new, or delete, and it is
not a postfix-expression (believe me!). So a compiler can't parse
the expression in question as 'sizeof unary-expression'.
Regards,
tx

[jeffc]

"Roy Yao" <fl***@263.ne t> wrote in message
news:bk******** ***@mail.cn99.c om...

Hello Keerthi,

Thanks for your enthusiasm.

My email to you was rejected by your mail server, so I reply you here.

In this expression, what confused me is how the compilers (or ANSI C)
determine the combination of operator sizeof, (type) and *.

In my opion it should equal to expression "sizeof( (int)(*p) )". The
reason is that operator sizeof, (type) and * have the same
precedence, and they combine from right to left. But the compilers prefer
"(sizeof(in t))* (p)".

Now can you give me a convictive explain from the precedence and
combination order of operator ?

sizeof is a function, and the parameter it takes is whatever is inside the
parens. If you wrote
sizeof((int)*p) , you'd evaluate the expression inside the outer parens
first. You cast whatever
*p is to an int, then take the size of that. Same as sizeof(int). But what
you wrote in your subject
is not exactly the same as either of the 2 options in your text message.

[Kevin Goodsell]

jeffc wrote:

sizeof is a function,
No, it's not. It is an operator.
and the parameter it takes is whatever is inside the
parens. If you wrote
sizeof((int)*p) , you'd evaluate the expression inside the outer parens
first.

No, sizeof's operand is not evaluated.

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

[Ron Natalie]

"jeffc" <no****@nowhere .com> wrote in message news:3f******** @news1.prserv.n et...

sizeof is a function,
sizeof is not a function. It's an operator.
and the parameter it takes is whatever is inside the
parens.
Sorry untrue. The parens aren't strictly requird. The grammar of sizeof
is:

sizeof unary-expression // note no parens here.
swizeof ( type-id )
you'd evaluate the expression inside the outer parens
first.

Parens have no bearing on order of evaulation in C++.

[Xenos]

"jeffc" <no****@nowhere .com> wrote in message
news:3f******** @news1.prserv.n et...

"Roy Yao" <fl***@263.ne t> wrote in message
news:bk******** ***@mail.cn99.c om...

Hello Keerthi,

Thanks for your enthusiasm.

My email to you was rejected by your mail server, so I reply you here.

In this expression, what confused me is how the compilers (or ANSI C)
determine the combination of operator sizeof, (type) and *.

In my opion it should equal to expression "sizeof( (int)(*p) )". The
reason is that operator sizeof, (type) and * have the same
precedence, and they combine from right to left. But the compilers prefer "(sizeof(in t))* (p)".

Now can you give me a convictive explain from the precedence and
combination order of operator ?
sizeof is a function, and the parameter it takes is whatever is inside the
parens. If you wrote
sizeof((int)*p) , you'd evaluate the expression inside the outer parens
first. You cast whatever
*p is to an int, then take the size of that. Same as sizeof(int). But

what you wrote in your subject
is not exactly the same as either of the 2 options in your text message.

Additionally, his second option: (sizeof(int)*(p )) is exactly the same as
the one in his subject line.
DrX.

[Xenos]

"jeffc" <no****@nowhere .com> wrote in message
news:3f******** @news1.prserv.n et...

sizeof is a function, and the parameter it takes is whatever is inside the
parens. If you wrote
sizeof((int)*p) , you'd evaluate the expression inside the outer parens
first. You cast whatever
*p is to an int, then take the size of that. Same as sizeof(int). But what you wrote in your subject
is not exactly the same as either of the 2 options in your text message.

No, sizeof is an operator. The paranteses are only required for uses with a
type expression. Any other use only need them because of precedence.
Examples are:

sizeof(int)
sizeof 12345
sizeof 'a'
sizeof (a + b)

DrX.