CATEGORII DOCUMENTE |

Asp | Autocad | C | Dot net | Excel | Fox pro | Html | Java |

Linux | Mathcad | Photoshop | Php | Sql | Visual studio | Windows | Xml |

+ Font mai mare | - Font mai mic

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

or ` `

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

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

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)`

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

or ` `

. The `&&`

gives ` `

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

gives ` `

only when both operands are zero. The `!`

gives ` `

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.

/* 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 ` `

or ` `

result is anded with `a!`

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

Politica de confidentialitate | Termeni si conditii de utilizare |

Vizualizari: 711

Importanta:

Termeni si conditii de utilizare | Contact

© SCRIGROUP 2024 . All rights reserved