This question already has answers here:
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Closed 3 months ago.
`
a = 10;
int *ptr = &a;
printf("%d %d\n", a, ++*ptr);
`
The output is - 11 11
How is it evaluated??
This is undefined behaviour, so the result could be anything. There is no sequence point in the line, which means that both operations are unsequenced - either argument could be evaluated first, or both simultaneously (see https://en.wikipedia.org/wiki/Sequence_point and John Bollinger's comment).
For example, when evaluating with the clang compiler, this is the output:
<source>:5:26: warning: unsequenced modification and access to 'a' [-Wunsequenced]
printf("%d %d\n", a, ++a);
~ ^
1 warning generated.
Execution build compiler returned: 0
Program returned: 0
2 3
See this answer for more: Order of operations for pre-increment and post-increment in a function argument?
Related
This question already has answers here:
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Closed 2 years ago.
Can anybody tell me how the answer of this code is 16 25
#include<stdio.h>
#define sqr(x) ++x * ++x
int main()
{
int a = 3, z;
z = ++a * ++a;
a -= 3;
printf("%d %d", sqr(a), z);
return 0;
}
Compiling the code with -Wall option gives the following warning:
[Warning] operation on 'a' may be undefined [-Wsequence-point]
The results are platform and version dependent. Using such an expression results undefined behaviour. Therefore, such an expression must not be used.
This question already has answers here:
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Sequence Points between printf function args; does the sequence point between conversions matter?
(3 answers)
Closed 3 years ago.
Consider code below:
#include <stdio.h>
int main()
{
int x=0,y=5;
printf("x=%d,x_1=%d,sum=%d",x++,x,y+x);
return 0;
}
My assumption on this code was that, x would be printed as 0 and later on postincrement x_1 would be 1 and y+x be 5+1=6
Actual result is x as 0 as expected , x_1 as 1 as expected. But y+x be 5. I am unsure why x retains its previous value though an postincrement had occured. Could you please help clarify this?
I used gcc compiler for the same.
In
printf("x=%d,x_1=%d,sum=%d", x++, x, y+x);
// (a) (b) (b)
you are both updating x (a) and using its value (b) in the same expression (with no intervening sequence point).
That's Undefined Behaviour.
Try
printf("x=%d,x_1=%d,sum=%d", x, x + 1, y + x + 1);
x++;
This is standard undefined behaviour, order of evalution of function arguments is non deterministic. Read [Why are these constructs using pre and post-increment undefined behavior?
This question already has answers here:
Undefined behavior and sequence points
(5 answers)
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Closed 9 years ago.
How to interpret these pre increment operators?
Pre increment operators have right to left associativity, so the right most i will be incremented or all the i's will be incremented once?
main()
{
int i=3,j;
j=++i*++i*++i;
printf("%d",j);
}
Answer is 216.
According to the c11 standard, ยง6.5 par. 2 of the working draft, expressions like these are indeed undefined.
++i increments i before the operation.
You code is equivalent to :
int i=3,j;
j=(i+1)*(i+2)*(i+3);
i++;i++;i++;
printf("%d",j);
This will output 4*5*6=120
Answer is 150
Is it equal to (++i * ++i) * ++i, first ++i increments i (i=4), second ++i increments i (i=5) but it is the same i so 5*5 = 25.
Finally 25 * ++i = 150
This question already has answers here:
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Closed 10 years ago.
Cannot explain the output of the following program. According to my knowledge the output should be 19, but running it gives me output of 20. I used gcc to compile this program.
int main()
{
int x, y = 5;
x = ++y + ++y + --y;
printf("%d", x);
return 0;
}
Your program exploits undefined behavior as you modify y multiple times between two sequence points (in your case, the end of the statement). If you turn on warnings with -Wall, your compiler is probably even going to warn you about that.
6+7+6 = 19
so 19 will be your output
This question already has answers here:
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Closed 3 years ago.
I am new to C, i have an Increment operator program in C
#include<stdio.h>
main(){
int a, b;
a = 2;
b = a + ++a + ++a;
printf("%d", b);
getchar();
}
The output is 10, can someone explain me how the output will be 10 .
a + ++a + ++a;
Behaviour for this is undefined.
The compiler might generated code that evaluated this as 2 + 4 + 4 or 3 + 3 + 4, but any combination/ordering of incrementing and accessing is a "valid" result.
This is undefined, the ++i can happen in any order.
Function call arguments are also ambigiously evaluated, e.g. foo(++i,++i).
Not all operator chains are undefined, a||b||c is guaranteed to be left-to-right, for example.
The guarantees are made in places known as sequence points although this terminology is being deprecated and clarified in C++0x.
What's odd in your example is that neigher 2+3+4 nor 4+4+3 happened, so the compiler evaluated the left side first in one step and the right side first in the other. This was probably an optimisation to flatten the depencency graph.