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

[Mark A. Odell]

sh**********@ho tmail.com (sam) wrote in
news:25******** *************** ***@posting.goo gle.com:

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

It's called a short-circuit. If expr("1st",1) is true, then there is no
need to bother evaluting expr("3rd",0) and then expr("2nd",0), so it does
not. What you have seen is correct.

--
- Mark ->
--

[Christopher Benson-Manica]

sam <sh**********@h otmail.com> spoke thus:

int main()
{
if(expr("1st",1 ) || expr("2nd",0) && expr("3rd",1));
return 0;
} 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

Does this make sense?

* > +
A + B * C equals A + (B * C)

&& > ||
A || B && C equals A || (B && C)

As Mark stated, the last expression is subject to short-circuit
evaluation, and thus there is no need to evaluate B && C (since A is
true in this case). Notice that

B && C || A

in this case calls #2 and #1, but not #3, again because of
short-circuit evaluation.

--
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.

[Eric Sosman]

sam wrote:

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

"Operator precedence" and "order of evaluation" are
two different things. Precedence dictates that the
expression means

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

rather than

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

.... but precedence alone doesn't determine the order in
which the three expr() calls are made.

The evaluation order is determined not by the precedence,
but by the definitions of the || and && operators. In this
case, the rule for || says that if expr("1st",1) produces a
non-zero value, the second sub-expression is not evaluated
at all. If the expr("1st",1) yields zero, the second sub-
expression *is* evaluated -- and in that evaluation, there
is a similar rule for && that governs the order in which
expr("2nd",0) and expr("3rd",0) are evaluated.

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

--
Er*********@sun .com

[osmium]

Mark A. Odell writes:

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

It's called a short-circuit. If expr("1st",1) is true, then there is no
need to bother evaluting expr("3rd",0) and then expr("2nd",0), so it does
not. What you have seen is correct.

This is nasty stuff! Once prompted, I remember the short circuit rule and
how I once wanted such a rule in Pascal. But digging this rule out of the
BNF for C seems like a real challenge. However I would expect it to be
noticeable in syntax charts. Does any one know of a site containing syntax
charts for C? I looked and failed to find one. I know there is a book, I
saw one several years ago, but I didn't like it.

[Mark A. Odell]

"osmium" <r1********@com cast.net> wrote in
news:bu******** ****@ID-179017.news.uni-berlin.de:

> 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

It's called a short-circuit. If expr("1st",1) is true, then there is no
need to bother evaluting expr("3rd",0) and then expr("2nd",0), so it
does not. What you have seen is correct.

This is nasty stuff!

Nasty nothing. It's dog simple.

if (a || b)

Why on earth would you ever evaluate b if a is true? Very simple. I
believe we need to think about sequence points here.

--
- Mark ->
--

[Eric Sosman]

osmium wrote:

Mark A. Odell writes:

It's called a short-circuit. If expr("1st",1) is true, then there is no
need to bother evaluting expr("3rd",0) and then expr("2nd",0), so it does
not. What you have seen is correct.
This is nasty stuff! Once prompted, I remember the short circuit rule and
how I once wanted such a rule in Pascal. But digging this rule out of the
BNF for C seems like a real challenge.

A challenge, indeed, because the short-circuit rule is
not present in the BNF in the first place.
However I would expect it to be
noticeable in syntax charts.

Why? The syntax will tell you what arrangements of
symbols are valid C utterances, but will say nothing about
what those utterances mean (if, indeed, they mean anything
at all).

--
Er*********@sun .com

[Sidney Cadot]

Mark A. Odell wrote:

"osmium" <r1********@com cast.net> wrote in
[...snip...]
Nasty nothing. It's dog simple.

if (a || b)

Why on earth would you ever evaluate b if a is true?

If this wasn't a rhetorical question, I /could/ think of an answer. For
example: short-circuit evaluation may, under some circumstances,
negatively impact the size and/or speed of generated assembly code
(e.g., by introducing pipeline stalls).

Best regards, Sidney

[glen herrmannsfeldt]

Eric Sosman wrote:

(snip)

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

(snip)
... but precedence alone doesn't determine the order in
which the three expr() calls are made. The evaluation order is determined not by the precedence,
but by the definitions of the || and && operators. In this
case, the rule for || says that if expr("1st",1) produces a
non-zero value, the second sub-expression is not evaluated
at all. If the expr("1st",1) yields zero, the second sub-
expression *is* evaluated -- and in that evaluation, there
is a similar rule for && that governs the order in which
expr("2nd",0) and expr("3rd",0) are evaluated.

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

Funny. There is a very similar discussion in comp.lang.fortr an,
except that Fortran does not guarantee short circuit evaluation.

The discussion of precedence and evaluation order is there, though.

-- glen

[Eric Sosman]

Sidney Cadot wrote:

Mark A. Odell wrote:

"osmium" <r1********@com cast.net> wrote in

[...snip...]
Nasty nothing. It's dog simple.

if (a || b)

Why on earth would you ever evaluate b if a is true?

If this wasn't a rhetorical question, I /could/ think of an answer. For
example: short-circuit evaluation may, under some circumstances,
negatively impact the size and/or speed of generated assembly code
(e.g., by introducing pipeline stalls).

You're missing the point, I think. Short-circuit
evaluation isn't about efficiency, but about correctness.
The || and && operators are *defined* to work this way;
an implementation that evaluated `b' when `a' was true
would not be an implementation of C.

--
Er*********@sun .com