C pitfall

[Henk]

Just found a bug. Maybe I posted it before.

Code: Select all

a + b ? c : d + 
f + g 

is not the same as

a + (b ? c : d) + 
f + g 

I think I will always place parenthesis when using ?: in the future for this is certainly not the first time.

Don't ask me what happens if + would be &&.

[Lasse Hansen]

Just found a bug. Maybe I posted it before.

Code: Select all

a + b ? c : d + 
f + g 

is not the same as

a + (b ? c : d) + 
f + g 

I think I will always place parenthesis when using ?: in the future for this is certainly not the first time.

Don't ask me what happens if + would be &&.

Try using this:

Code: Select all

Operator Preceedence in C (C++ removed)
(3)----------------------------------		(9)----------------------------------
++			increment                       ==			equal to
--                                          !=
+			unary plus                      (10)---------------------------------
-                                           &			bitwise AND
!			logical NOT                     (11)---------------------------------
~			bitwise NOT                     ^			bitwise XOR
(type)		cast                            (12)---------------------------------
*			indirection, not multiply       |
&			address of                      (13)---------------------------------
sizeof                                      &&
new                                         (14)---------------------------------
delete                                      ||
(5)----------------------------------       (15)---------------------------------
*			multiplication                  ?:
/                                           (16)---------------------------------
%			modulo                          =			direct assignment
(6)----------------------------------       +=
+			addition                        -=
-                                           *=
(7)----------------------------------       /=
<<			bitwise left shift              %=
>>                                          <<=
&#40;8&#41;----------------------------------       >>=
<			less than                       &=
<=                                          ^=
>                                           |=
>=                                          &#40;18&#41;---------------------------------
											,			comma
											-------------------------------------
											
&#123;	++	--	+	-	!	~	&#40;type&#41;	*	&	sizeof	new	delete	&#125;
&#123;	*	/	%	&#125;	
&#123;	+	-	&#125;	
&#123;	<<	>>	&#125;
&#123;	<	<=	>	>=	&#125;	
&#123;	==	!=	&#125;	
&#123;	&	&#125;	&#123;	^	&#125;	&#123;	|	&#125;	&#123;	&&	&#125;	&#123;	||	&#125;
&#123;	=	+=	-=	*=	/=	%=	<<=	>>=	&=	^=	|=	&#125;

[Henk]

Ok this means

Code: Select all

a + b ? c : d + 
 f + g 

 is the same as 

( a + b) ? c : (d + 
 f + g )

Am I right ? And the same holds if + would be && or ||

[Lasse Hansen]

Ok this means

Code: Select all

a + b ? c : d + 
 f + g 

 is the same as 

( a + b) ? c : (d + 
 f + g )

Am I right ? And the same holds if + would be && or ||

Yes, both + and &&, || has higher precedence than ?:

One mistake I have made often is that

Code: Select all

if (a & b == c)

is different from

Code: Select all

if ((a & b) == c)

[Rein Halbersma]

Decent compilers warn against missing parentheses with bitwise operators.

[bob]

Just found a bug. Maybe I posted it before.

Code: Select all

a + b ? c : d + 
f + g 

is not the same as

a + (b ? c : d) + 
f + g 

I think I will always place parenthesis when using ?: in the future for this is certainly not the first time.

Don't ask me what happens if + would be &&.

You need to study the operator precedence chart for C, then this ceases to be a trap.

[lucasart]

Operator precedence is simple: either you know the rules or you don't, but NEVER assume or guess!

BTW, this is not just for operator precedence…

[kbhearn]

Precedence is easy, always use brackets where it's not obvious - makes things more readable anyways.

&& and || are the really fun ones. in order to support forms like:

if (ptr && (*ptr > 0)) { ... }

&& actually guarantees that the right side of the operator will not be evaluated at all if the left side is false. This of course could be confusing as heck if you're doing a long list of function calls and want to check if they all return true and then wonder why the last one never gets called :)

[Henk]

Precedence is easy, always use brackets where it's not obvious - makes things more readable anyways.

&& and || are the really fun ones. in order to support forms like:

if (ptr && (*ptr > 0)) { ... }

&& actually guarantees that the right side of the operator will not be evaluated at all if the left side is false. This of course could be confusing as heck if you're doing a long list of function calls and want to check if they all return true and then wonder why the last one never gets called

Expressions with many brackets are difficult to edit. Best is to split expressions. But I don't know if compiler will optimize them.

You easily get these bugs when substituting expressions back in their parent using copy paste (in a hurry) but forget to add brackets.