Undefined Value 2 - Revision history

Arjun Suresh at 18:13, 23 July 2014

2014-07-23T18:13:33Z

Arjun Suresh at 18:12, 23 July 2014

2014-07-23T18:12:06Z

Arjun Suresh at 18:11, 23 July 2014

2014-07-23T18:11:36Z

Arjun Suresh at 08:50, 14 July 2014

2014-07-14T08:50:04Z

Arjun Suresh: /* Precedence Rule */

2014-07-04T08:57:51Z

‎Precedence Rule

Arjun Suresh at 11:59, 3 July 2014

2014-07-03T11:59:44Z

Arjun Suresh at 11:59, 3 July 2014

2014-07-03T11:59:05Z

Arjun Suresh at 11:58, 3 July 2014

2014-07-03T11:58:20Z

Arjun Suresh at 11:56, 3 July 2014

2014-07-03T11:56:57Z

Arjun Suresh: /* {{Template:Author|Arjun Suresh|{{arjunweb}} }} */

2014-05-27T07:40:36Z

‎{{Template:Author|Arjun Suresh|{{arjunweb}} }}

@@ Line 22: / Line 22: @@
   a = a++;
-There is a side effect on $a$, which can happen anytime before the next sequence point. So, as per C standard, the output is simply '''UNDEFINED'''.
+There is a side effect on $a$, which can happen anytime before the next sequence point. So, as per C standard, the output is simply '''UNDEFINED'''. This is shown by the output from three different compilers gcc, icc and clang on an Ubuntu system.
   undefined.c:5:6: warning: operation on ‘a’ may be undefined [-Wsequence-point]
      a = a++;
@@ Line 35: / Line 37: @@
   asuresh@parambara:~$ ./a.out
 Undefined value means compiler can give any value. i.e.; different compilers or even different versions of the same compiler can give different answers. As per C standard, no programmer should write this code. This is different from compiler dependent, in which case the output is clearly defined by the compiler and programmer can write those code as long as he is aware of the compiler. Example of compiler dependent code is sizeof(int).

← Older revision		Revision as of 18:12, 23 July 2014
Line 37:		Line 37:


−	Undefined value means compiler can give any value. i.e.; different compilers or even different versions of the same compiler can give different answers. As per C standard, no programmer should write this code. This is different from compiler dependent, in which case the output is clearly defined by the compiler and programmer can write those code as long as he is aware of the compiler. Example of compiler dependent code is sizeof(int).	+	Undefined value means compiler can give any value. i.e.; different compilers or even different versions of the same compiler can give different answers. As per C standard, no programmer should write this code. This is different from compiler dependent, in which case the output is clearly defined by the compiler and programmer can write those code as long as he is aware of the compiler. Example of compiler dependent code is sizeof(int).

	===Precedence Rule===		===Precedence Rule===

@@ Line 6: / Line 6: @@
+{
     int a = 2;
-    a = ++a;
+    a = a++;
     printf("%d", a);
@@ Line 15: / Line 15: @@
 ==={{Template:Author|Arjun Suresh|{{arjunweb}} }}===
-The answer to this is "Undefined". C standard says that the side effects of an operation (for b = ++a; modification of a is a side-effect) need to be completed only before the next [https://en.wikipedia.org/wiki/Sequence_point sequence point]. This relaxation is given so that the compiler would be able to generate the most optimal code (which run faster). But as a consequence, programmer shouldn't do multiple writes to a memory location within a sequence point or otherwise the result would be undefined.
+The answer to this is "Undefined". C standard says that the side effects of an operation (for b = a++; modification of a is a side-effect) need to be completed only before the next [https://en.wikipedia.org/wiki/Sequence_point sequence point]. This relaxation is given so that the compiler would be able to generate the most optimal code (which run faster). But as a consequence, programmer shouldn't do multiple writes to a memory location within a sequence point or otherwise the result would be undefined.
   Undefined behavior can occur if ''Between two consecutive sequence points, an object is modiﬁed more than once, or is modiﬁed and the prior value is read other than to determine the value to be stored''
 So, in the statement
-  a = ++a;
+  a = a++;
 There is a side effect on $a$, which can happen anytime before the next sequence point. So, as per C standard, the output is simply '''UNDEFINED'''.
   Undefined value means compiler can give any value. i.e.; different compilers or even different versions of the same compiler can give different answers. As per C standard, no programmer should write this code. This is different from compiler dependent, in which case the output is clearly defined by the compiler and programmer can write those code as long as he is aware of the compiler. Example of compiler dependent code is sizeof(int).

@@ Line 42: / Line 42: @@
 $i$++ or ++$i$ can happen first. Suppose ++$i$ happened first. It'll surely return $i+1$. But whether this incremented $i$ is used by $i$++ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.
+[http://stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points Discussion in stackoverflow]
 {{Template:FBD}}

← Older revision		Revision as of 08:57, 4 July 2014
Line 38:		Line 38:
	x = i++ * ++i;		x = i++ * ++i;

		+	After applying precedence rule, we get
		+	x = ((i++) * (++i));
	$i$++ or ++$i$ can happen first. Suppose ++$i$ happened first. It'll surely return $i+1$. But whether this incremented $i$ is used by $i$++ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.		$i$++ or ++$i$ can happen first. Suppose ++$i$ happened first. It'll surely return $i+1$. But whether this incremented $i$ is used by $i$++ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.

← Older revision		Revision as of 11:59, 3 July 2014
Line 37:		Line 37:
	x = i++ * ++i;		x = i++ * ++i;

−	$i$++ or ++$i$ can happen first. Suppose ++$i$ happened first ~~and it~~'ll surely return $i+1$. But whether this incremented i is used by $i$++ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.	+	$i$++ or ++$i$ can happen first. Suppose ++$i$ happened first. It'll surely return $i+1$. But whether this incremented $i$ is used by $i$++ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.

@@ Line 32: / Line 32: @@
   x = ((a*b) + (c*d));
-Thus the first $*$ has operands a and b, the second $*$ has operands $c$ and $d$, the $+$ has operands returned by the result of two $*$ and $=$ has left operand $x$ and right operand the result of $+$. But, during execution $(a*b)$ or $(c*d)$ can occur first as both these won't be violating the precedence rule.
+Thus the first $*$ has operands $a$ and $b$, the second $*$ has operands $c$ and $d$, the $+$ has operands returned by the result of two $*$ and $=$ has left operand $x$ and right operand the result of $+$. But, during execution $(a*b)$ or $(c*d)$ can occur first as both these won't be violating the precedence rule.
 Similarly, if we take
   x = i++ * ++i;
-$i++$ or $++i$ can happen first. Suppose $++i$ happened first and it'll surely return $i+1$. But whether this incremented i is used by $i++$ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.
+$i$++ or ++$i$ can happen first. Suppose ++$i$ happened first and it'll surely return $i+1$. But whether this incremented i is used by $i$++ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.

← Older revision		Revision as of 11:56, 3 July 2014
Line 24:		Line 24:

	Undefined value means compiler can give any value. i.e.; different compilers or even different versions of the same compiler can give different answers. As per C standard, no programmer should write this code. This is different from compiler dependent, in which case the output is clearly defined by the compiler and programmer can write those code as long as he is aware of the compiler. Example of compiler dependent code is sizeof(int).		Undefined value means compiler can give any value. i.e.; different compilers or even different versions of the same compiler can give different answers. As per C standard, no programmer should write this code. This is different from compiler dependent, in which case the output is clearly defined by the compiler and programmer can write those code as long as he is aware of the compiler. Example of compiler dependent code is sizeof(int).
		+
		+	===Precedence Rule===
		+	Undefined behaviour is happening not because C is violating precedence rule. Precedence (and associativity which is used when precedence of operators are same) rule is used to specify the operands for operations. But the actual execution order might be different. For example:
		+	x = ab+cd;
		+
		+	After applying precedence rule, we get
		+	x = ((ab) + (cd));
		+
		+	Thus the first $$ has operands a and b, the second $$ has operands $c$ and $d$, the $+$ has operands returned by the result of two $$ and $=$ has left operand $x$ and right operand the result of $+$. But, during execution $(ab)$ or $(c*d)$ can occur first as both these won't be violating the precedence rule.
		+
		+	Similarly, if we take
		+	x = i++ * ++i;
		+
		+	$i++$ or $++i$ can happen first. Suppose $++i$ happened first and it'll surely return $i+1$. But whether this incremented i is used by $i++$ is not guaranteed. This increment can happen to $i$ ANYTIME before the next sequence point, which here is the ; at the end of the expression. This makes this code produce undefined behaviour.
		+

	{{Template:FBD}}		{{Template:FBD}}

@@ Line 17: / Line 17: @@
 The answer to this is "Undefined". C standard says that the side effects of an operation (for b = ++a; modification of a is a side-effect) need to be completed only before the next [https://en.wikipedia.org/wiki/Sequence_point sequence point]. This relaxation is given so that the compiler would be able to generate the most optimal code (which run faster). But as a consequence, programmer shouldn't do multiple writes to a memory location within a sequence point or otherwise the result would be undefined.
-  Undefined behavior can occur if ''Between two sequence points, an object is modiﬁed more than once, or is modiﬁed and the prior value is read other than to determine the value to be stored''
+  Undefined behavior can occur if ''Between two consecutive sequence points, an object is modiﬁed more than once, or is modiﬁed and the prior value is read other than to determine the value to be stored''
 So, in the statement a = ++a;