# 3.3. More logical expressions

This chapter has already shown how C makes no distinction between
‘logical’ and other values. The relational operators all give a
result of `0`

or `1`

for false and true,
respectively. Whenever the control of flow statements demand it, an
expression is evaluated to determine what to do next. A `0`

means ‘don't do it’; anything else means ‘do’. It means that
the fragments below are all quite reasonable.

while (a<b)... while (a).... if ( (c=getchar()) != EOF )...

No experienced C programmer would be surprised by any of them. The second
of them, `while (a)`

, is a common abbreviation for
`while (a != 0)`

, as you should be able to work
out.

What we need now is a way of writing more complicated expressions
involving these logical true and false values. So far, it has to be done
like this, when we wanted to say
`if(a<b AND c<d)`

if (a < b){ if (c < d)... }

It will not be a source of great amazement to find that there is a way of expressing such a statement.

There are three operators involved in this sort of operation: the logical
`AND &&`

, the logical `OR ||`

and
the `NOT !`

. The last is unary, the other two are binary.
All of them take expressions as their operands and give as results
either `1`

or `0`

.
The `&&`

gives `1`

only when both
of its operands are non-zero. The `||`

gives `0`

only when both operands are zero.
The `!`

gives `0`

if its operand is
non-zero and vice versa. Easy really. The results are of type
`int`

for all three.

Do not confuse `&`

and `|`

(the bitwise
operators) with their logical counterparts. They are not the same.

One special feature of the logical operators, found in very few of the
other operators, is their effect on the sequence of evaluation of an
expression. They evaluate left to right (after precedence is taken into
account) and every logical expression ceases evaluation as soon as the
overall result can be determined. For example, a sequence of
`||`

s can stop as soon as one operand is found to be non-zero.
This next fragment guarantees never to divide by zero.

if (a!=0 && b/a > 5)... /* alternative */ if (a && b/a > 5)

In either version `b/a`

will only be evaluated if a is
non-zero. If a were zero, the overall result would already have been
decided, so the evaluation must stop to conform with C's rules for the
logical operators.

The unary NOT is simple. It isn't all that common to see it in use largely because most expresssions can be rearranged to do without it. The examples show how.

if (!a)... /* alternative */ if (a==0)... if(!(a>b)) /* alternative */ if(a <= b) if (!(a>b && c<d))... /* alternative */ if (a<=b || c>=d)...

Each of the examples and the alternatives serve to show ways of avoiding
(or at least doing without) the `!`

operator. In fact, it's most
useful as an aid to readability. If the problem that you are solving has a
natural logical relationship inherent in it—say the ```
(b*b-4*a*c)
> 0
```

found in quadratic equation solving—then it probably
reads better if you write `if( !((b*b-4*a*c) > 0))`

than
`if( (b*b-4*a*c) <= 0)`

—but it's up to you. Pick the one
that feels right.

Most expressions using these logical operators work out just about right in terms of the precedence rules, but you can get a few nasty surprises. If you look back to the precedence tables, you will find that there are some operators with lower precedence than the logical ones. In particular, this is a very common mistake:

if(a&b == c){...

What happens is that `b`

is compared for equality with
`c`

, then the `1`

or `0`

result is anded
with `a!`

Some distinctly unexpected behaviour has been caused
by that sort of error.