Logical And

[sam]

Please look at the code below
#include <stdio.h>

int expr(char str[], int i){
printf("%s \n",str);
return i;
}

int main()
{
if(expr("1st",1 ) || expr("2nd",0) && expr("3rd",1));
return 0;
}

output
-------
1st

As && has an higher precedence over ||
then it should call expr("2nd",0) or expr("3rd",0)
first then why it calls (expr("1st",1) first

Regards
Shiju

[CBFalconer]

Old Wolf wrote:

> if(expr("1st",1 ) || expr("2nd",0) && expr("3rd",1));

Summary: Operator precedence governs the meaning of an
expression with multiple operators, but does not control
the order in which the operands are evaluated.

Finally a sensible answer in this thread. A corollary is: If you
want to use complex logical expressions, parenthise them so there
is NO DOUBT, NO DOUBT WHATSOEVER, what they mean. You will save a
lot of headaches, both your own and others.

(((((How) (would) (that) (help))?) (The (expressions (
((A || B) && C)
(and)
(A || (B && C))
) (have) ((the) (same) ((order) (of) (evaluation))). )
((There) (was) (never) ((any) (doubt) (about) (((the) (meaning))
(of) ((the) (expression)))) )).

Not so.

A B Eval ((A || B) && C) Eval (A || (B && C))
== == =============== ==== =============== =====
0 0 A B done=0 A B done=0
0 1 A B C done=C A B C done=C
1 0 A C done=C A B done=0
1 1 A C done=C A done=1

If I have made no mistakes. At any rate, the expression values
and side effects are different.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Irrwahn Grausewitz]

CBFalconer <cb********@yah oo.com> wrote:

Old Wolf wrote: <snip>

(((((How) (would) (that) (help))?) (The (expressions (
((A || B) && C)
(and)
(A || (B && C))
) (have) ((the) (same) ((order) (of) (evaluation))). )
((There) (was) (never) ((any) (doubt) (about) (((the) (meaning))
(of) ((the) (expression)))) )).

Not so.

A B Eval ((A || B) && C) Eval (A || (B && C))
== == =============== ==== =============== =====
0 0 A B done=0 A B done=0
0 1 A B C done=C A B C done=C
1 0 A C done=C A B done=0

^^^^^^^^^^ 1 1 A C done=C A done=1

If I have made no mistakes.
Maybe it's me who is mistaken, but shouldn't the marked (^^^)
line read: A done=1 (just like the one below it)?
At any rate, the expression values
and side effects are different.

However, your claim is of course correct.

Regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.eskimo.com/~scs/C-faq/top.html
acllc-c++ faq : http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Dan Pop]

In <40**********@m indspring.com> pete <pf*****@mindsp ring.com> writes:

Dan Pop wrote:

In <40************ ***********@new sreader02.highw ay.telekom.at> Robert Bachmann <Ro************ *@rbdev.net> writes:

>Keith Thompson wrote:
>> If I saw code that used "if (a & b)", my first assumption would be
>> that it was a typo for "if (a && b)", and my second would be that the
>> author really intended to test the bitwise "and" of a and b.
>
>When writing something like "if (a & b)" it is a good idea to
>write "if (a & b) /*bitwise*/" instead.
>On the other hand it looks a little bit funny to me, just like
> some beginner who writes "int i; /*an integer variable*/" ;-)

The real solution is to write it as:

if ((a & b) != 0) ...

No silly comments needed to remove any doubt WRT your real intentions.
It is seldom a good idea to skip the explicit comparison.

I believe that you're implying that it's a good idea
to skip the explicit comparison of the result of a logical operation.

You wouldn't write
if ((a && b) != 0)

right ?

Right. When dealing with a logical expression, the explicit comparison
of the result is pointless, because the intent is obvious. Ditto for
numeric variables that are used as flags (conceptually booleans), where
the intent is equally obvious. E.g. I would write:

int i, access_ok = 0;
...
if (i != 0) /* do this */ ;
if (access_ok) /* do that */ ;

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[pete]

Dan Pop wrote:

When dealing with a logical expression, the explicit comparison
of the result is pointless, because the intent is obvious. Ditto for
numeric variables that are used as flags (conceptually booleans),
where the intent is equally obvious. E.g. I would write:

int i, access_ok = 0;
...
if (i != 0) /* do this */ ;
if (access_ok) /* do that */ ;

Thank you.

--
pete

[Christopher Benson-Manica]

Old Wolf <ol*****@inspir e.net.nz> spoke thus:

(((((How) (would) (that) (help))?) (The (expressions (
((A || B) && C)
(and)
(A || (B && C))
) (have) ((the) (same) ((order) (of) (evaluation))). )
((There) (was) (never) ((any) (doubt) (about) (((the) (meaning))
(of) ((the) (expression)))) ))

Was that intended to resemble (horrible) Lisp code? ;D

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.