Why does post or pre incremenent or decrement does not work inside a sizeof operator?

T

Tarun

Hi All,
I have written the following prog.

int main()
{
int val = 4;
printf("size of val = %d, val = %d",sizeof(++val),val);
}
output: size of val = 2, val = 4
The output expected was : size of val = 2, val = 5

Can somebody explain why?

Thanks in advance

Regards
Tarun
 
W

Walter Roberson

I have written the following prog.
int main()
{
int val = 4;
printf("size of val = %d, val = %d",sizeof(++val),val);
}
output: size of val = 2, val = 4
The output expected was : size of val = 2, val = 5
Can somebody explain why?

The order of evaluation of parameters to a function is
undefined in the standard. It is legal (and not uncommon)
that the last parameter, val, would be evaluated before
the next-to-last parameter, ++val .

The operation of ++val and val++ is defined in terms of
"sequence points": the increment takes place -sometime- between
the beginning of the sequence point and the end, with it being
undefined as to exactly when. If you attempt to use the same
variable within the same sequence point, it isn't defined as to
whether you will get the old or new value for the other
references -- it isn't even certain that you will always get
the same order for the same compiler (as compilers are allowed
to apply optimizations within sequence points.)

As a rough approximation, sequence points are usually present
at the beginning and end of expressions, but within expressions
only && and || force sequence points (and possibly the ','
sequencing operator... I use that so seldom that I
would have to look up it's properties to be sure.)
 
J

Jirka Klaue

Walter Roberson:
Tarun:



The order of evaluation of parameters to a function is
undefined in the standard. It is legal (and not uncommon)
that the last parameter, val, would be evaluated before
the next-to-last parameter, ++val .

That's true but unrelated to the code above. ;-)
The operand of sizeof is evaluated only in terms of its type.

Jirka
 
P

pete

Walter said:
The order of evaluation of parameters to a function is
undefined

The order is called "unspecified".
in the standard. It is legal (and not uncommon)
that the last parameter, val, would be evaluated before
the next-to-last parameter, ++val .

No. That's not it.
The sizeof operator doesn't evaluate it's operand.

/* BEGIN new.c */

#include<stdio.h>

int main(void)
{
int val = 4;

sizeof(++val);
sizeof(++val);
sizeof(++val);
sizeof(++val);
sizeof(++val);
sizeof(++val);
printf("size of val = %d, val = %d",sizeof(++val),val);
return 0;
}

/* END new.c */
 
R

Richard Bos

Yes. The ISO C Standard demands it.
The order of evaluation of parameters to a function is
undefined in the standard.

This has nothing whatsoever to do with the problem (though it _is_ true,
and would have been a problem had the OP used any other operator than
sizeof. For example, printf("%d, %d", 3 * ++val, val) would have had the
problem you describe. Except that it's even worse: it's not just the
order of evaluation that is undefined, but the entire outcome of the
program from then on. A crash would not be out of line.)

The real problem, if it is one, is that the Standard includes this:

# If the type of [sizeof's] operand is a variable length array
# type, the operand is evaluated; otherwise, the operand is not
# evaluated and the result is an integer constant.

Since ++val is not a VLA, it is not evaluated. It needn't be; its size
does not depend on its value.

Richard
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top