By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
457,915 Members | 1,337 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 457,915 IT Pros & Developers. It's quick & easy.

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

P: n/a
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

Nov 15 '05 #1
Share this Question
Share on Google+
5 Replies


P: n/a
In article <11*********************@f14g2000cwb.googlegroups. com>,
Tarun <ta*************@gmail.com> wrote:
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.)
--
Any sufficiently advanced bug is indistinguishable from a feature.
-- Rich Kulawiec
Nov 15 '05 #2

P: n/a
Walter Roberson:
Tarun:
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


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
Nov 15 '05 #3

P: n/a
Walter Roberson wrote:

In article <11*********************@f14g2000cwb.googlegroups. com>,
Tarun <ta*************@gmail.com> wrote:
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


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 */
--
pete
Nov 15 '05 #4

P: n/a
ro******@ibd.nrc-cnrc.gc.ca (Walter Roberson) wrote:
In article <11*********************@f14g2000cwb.googlegroups. com>,
Tarun <ta*************@gmail.com> wrote:
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?


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
Nov 15 '05 #5

P: n/a
Thanks all for the comments being provided.

Nov 15 '05 #6

This discussion thread is closed

Replies have been disabled for this discussion.