| blob | 93d38aa4dc604beaa12aabe29aee555bb0b0b70b |
2 <!-- This collection of hypertext pages is Copyright 1995, 1996 by Steve Summit. -->
3 <!-- This material may be freely redistributed and used -->
4 <!-- but may not be republished or sold without permission. -->
5 <html>
6 <head>
13 </head>
14 <body>
18 <pre>
19 if(x > max)
20 max = x;
21 </pre>
22 is perhaps deceptively simple.
23 Conceptually, we say that it checks whether the condition
25 The mechanics underlying C's conception of ``true''
26 and ``false,'' however, deserve some explanation.
27 We need to understand how true and false values are represented,
29 </p><p>As far as C is concerned,
30 a true/false condition can be represented as an integer.
31 (An integer can represent many values;
32 here we care about only two values:
33 ``true'' and ``false.''
34 The study of mathematics involving only two values is called
35 Boolean algebra, after George Boole, a mathematician who
36 refined this study.)
37 In C, ``false'' is represented by a value of 0 (zero),
38 and ``true'' is represented by any value that is nonzero.
41 when we have to pick a specific value for ``true,''
42 we'll pick 1.
47 The relational operators take two values, look at them, and
49 tested relation was true or false.
50 The complete set of relational operators in C is:
51 <br>
52 <br>
53 <pre>
60 </pre>
61 <br>
62 <br>
63 For example,
67 and
69 </p><p>We've now encountered perhaps the most easy-to-stumble-on
70 ``gotcha!'' in C:
73 If you accidentally write
74 <pre>
75 if(a = 0)
76 </pre>
77 (and you probably will at some point;
78 everybody
79 makes this mistake),
81 as you probably intended.
83 and then perform the ``true'' branch
86 so the ``true'' branch will never be taken!
87 (This could drive you crazy while debugging--you
90 whether it was supposed to be or not,
91 but the ``true'' branch is nevertheless not taken.)
92 </p><p>The relational operators work with arbitrary numbers
93 and generate true/false values.
94 You can
95 also
96 combine true/false values by using the
98 which take true/false values as operands
99 and compute new true/false values.
100 The three Boolean operators are:
101 <br>
102 <br>
103 <pre>
107 </pre>
108 <br>
109 <br>
111 takes two true/false values
112 and produces a true (1) result if both operands are true
114 the right-hand side is true).
116 takes two true/false values
117 and produces a true (1) result if either operand is true.
119 takes a single true/false value and negates it,
120 turning false to true and true to false
124 <pre>
126 ...
127 </pre>
128 Here we're expressing the
129 relation
132 as
135 </p><p>It's important to understand why the more obvious
136 expression
138 <pre>
140 </pre>
141 would not work.
142 The expression
144 is parsed by the compiler analogously to
148 and
150 Similarly,
151 the expression
154 and
156 and then see if the result is less than 10.''
163 </p><p>Relational and Boolean expressions are usually used
165 to be done or not done depending on some condition.
166 In these cases
167 what's actually checked is whether the expression representing
168 the condition has a zero or nonzero value.
169 As long as the expression is a relational or Boolean expression,
170 the interpretation is just what we want.
171 For example,
172 when we wrote
173 <pre>
174 if(x > max)
175 </pre>
178 and a 0 otherwise.
180 (or any nonzero value)
181 as true.
182 </p><p>But what if the expression is not a relational or Boolean expression?
183 As far as C is concerned,
184 the controlling expression
186 can
187 in fact
189 it doesn't have to ``look like'' a Boolean expression;
190 it doesn't have to contain relational or logical operators.
191 All C looks at
193 or anywhere else where it needs a true/false value)
194 is whether the expression evaluates to 0 or nonzero.
195 For example,
196 if you have
199 it's possible to write
200 <pre>
201 if(x)
203 </pre>
205 (since nonzero means ``true'').
206 </p><p>This possibility
208 doesn't have to ``look like'' a Boolean expression)
209 is both useful and potentially confusing.
210 It's useful when you have a variable or a function that is
211 ``conceptually Boolean,''
212 that is,
213 one
214 that you consider to hold
215 a true or false (actually nonzero or zero) value.
217 which contains a nonzero value when your program should run in
218 verbose mode and zero when it should be quiet,
219 you can write things like
220 <pre>
221 if(verbose)
222 printf("Starting first pass\n");
223 </pre>
224 and this code is both legal and readable,
225 besides which it does what you want.
228 which tests whether a character is an upper-case letter,
230 you might write
231 <pre>
232 if(isupper(c))
233 ...
234 </pre>
236 are useful and readable.
237 </p><p>However, you will eventually come across code like
238 <pre>
239 if(n)
240 average = sum / n;
241 </pre>
243 Here, the programmer wants to compute the average only if
245 (otherwise, of course, the code would divide by 0),
246 and the code works,
249 (as always)
250 interpreted as ``true'' if it is nonzero,
251 and ``false'' if it is zero.
252 </p><p>``Coding shortcuts''
253 like these
254 can
255 seem cryptic,
256 but they're also quite common,
257 so you'll need to be able to recognize them
258 even if you don't choose to write them in your own code.
259 Whenever you see code like
260 <pre>
261 if(x)
262 </pre>
263 or
264 <pre>
265 if(f())
266 </pre>
268 do not have obvious ``Boolean'' names,
270 or
272 </p><hr>
273 <p>
274 Read sequentially:
279 </p>
280 <p>
284 </p>
285 </body>
286 </html>