


                                                        Chapter 4
                                    ASSIGNMENT & LOGICAL COMPARES

Throughout this chapter, references are given to various ranges 
of variables.  This refers to the range of values that can be 
stored in any given variable.  Your compiler may use a different 
range for some of the variables since the ANSI standard does not 
define specific limits for all data types.  Consult the 
documentation for your compiler for the exact range for each of 
the variable types.


INTEGER ASSIGNMENT STATEMENTS
-----------------------------------------------------------------
Load the file named INTASIGN.C and display it    ================
for an example of assignment statements.            INTASIGN.C
Three variables are defined for use in the       ================
program and the remainder of the program is 
merely a series of illustrations of various kinds of assignment 
statements.  All three variables are defined on one line and have 
unknown values stored in them initially.

The first two lines of the assignment statements, lines 8 and 9, 
assign numerical values to the variables named a and b, and the 
next five lines illustrate the five basic arithmetic functions 
and how to use them.  The fifth is the modulo operator and gives 
the remainder if the two variables were divided.  It can only be 
applied to int or char type variables.  The char type variable 
will be defined in the description of the next example program.  
Lines 15 and 16 illustrate how to combine some of the variables 
in relatively complex math expressions.  All of the above 
examples should require no comment except to say that none of 
the equations are meant to be particularly useful except as 
illustrations.

The expressions in lines 17 and 18 are perfectly acceptable as 
given, but we will see later in this chapter that there is another 
way to write these for more compact code.


VERY STRANGE LOOKING CODE
-----------------------------------------------------------------
This leaves us with the last two lines which may appear to you as 
being very strange.  The C compiler scans the assignment 
statement from right to left, (which may seem a bit odd since we 
do not read that way), resulting in a very useful construct, 
namely the one given here.  The compiler finds the value 20, 
assigns it to c, then continues to the left finding that the 
latest result of a calculation should be assigned to b.  Thinking 
that the latest calculation resulted in a 20, it assigns it to b 
also, and continues the leftward scan assigning the value 20 to a 
also.  This is a very useful construct when you are initializing 

                                                         Page 4-1

                      Chapter 4 - Assignment and Logical Compares

a group of variables.  The statement in line 21 illustrates that 
it is possible to actually do some calculations to arrive at the 
value which will be assigned to all three variables.  The values 
of a, b, and c, prior to the beginning of the statement in line 
21 are used to calculate a value, which is then assigned to each 
of the variables.

As an aid to understanding, line 22 is given which contains 
parentheses to group the terms together in a meaningful way.  
Lines 20 and 22 are identical statements since they lead to the 
same result.

The program has no output, so compiling and executing this 
program will be very uninteresting. Since you have already 
learned how to display some integer results using the printf() 
function, it would be to your advantage to add some output 
statements to this program to see if the various statements do 
what you think they should do.  You can add your own assignment 
statements also to gain experience with them.


DEFINITIONS FIRST THEN EXECUTABLE STATEMENTS
-----------------------------------------------------------------
This would be a good time for a preliminary definition of a rule 
to be followed in C.  The variable definitions are always given 
before any executable statements in any program block.  This is 
why the variables are defined first in this program and in every 
C program.  If you try to define a new variable after executing 
some statements, your compiler will issue an error.  A program 
block is any unit of one or more statements surrounded by braces.  
More will be said about blocks later.


ADDITIONAL DATA TYPES
-----------------------------------------------------------------
Loading and editing MORTYPES.C will illustrate   ================
how some additional data types can be used.         MORTYPES.C
Once again we have defined a few integer type    ================
variables which you should be fairly familiar 
with by now, but we have added two new types, the char, and the 
float.  The char type of data is nearly the same as the integer 
except that it can only be assigned numerical values between 
-128 and 127 on most implementations of C, since it is stored 
in only one byte of memory.  The char type of data is usually 
used for ASCII data, more commonly known as text.  The text you 
are reading was originally written on a computer with a word 
processor that stored the words in the computer one character per 
byte.  In contrast, the integer data type is stored in two bytes 
of computer memory on nearly all microcomputers.

Keep in mind that, even though the char type variable was 
designed to hold a representation of an ASCII character, it can 
be used very effectively to store a very small value if desired.  

                                                         Page 4-2

                      Chapter 4 - Assignment and Logical Compares

Much more will be discussed on this topic in chapter 7 when we 
discuss strings.


DATA TYPE MIXING
-----------------------------------------------------------------
It would be profitable at this time to discuss the way C handles 
the two types char and int.  Most operations in C that are 
designed to operate with integer type variables will work equally 
well with character type variables because they are a form of an 
integer variable.  Those operations, when called on to use a char 
type variable, will actually promote the char data into integer 
data before using it.  For this reason, it is possible to mix 
char and int type variables in nearly any way you desire.  The 
compiler will not get confused, but you might.  It is good not 
to rely on this too much, but to carefully use only the proper 
types of data where they should be used.

The second new data type is the float type of data, commonly 
called floating point data.  This is a data type which usually 
has a very large range, a large number of significant digits, and 
a large number of computer words are required to store it.  The 
float data type has a decimal point associated with it and has an 
allowable range of from 3.4E-38 to 3.4E+38 when using most C 
compilers on microcomputers, and is composed of about 7 
significant digits.  Four bytes of memory are required to store a 
single float type variable.


HOW TO USE THE NEW DATA TYPES
-----------------------------------------------------------------
The first three lines of the program assign values to all nine of 
the defined variables so we can manipulate some of the data 
between the different types.

Since, as mentioned above, a char data type is in reality an 
integer data type, no special considerations need be taken to 
promote a char to an int, and a char type data field can be 
assigned to an int variable.  Most C compilers simply truncate 
the most significant bits and use the 8 least significant bits.  
An int type variable will translate correctly to a char type 
variable if the value is within the range of -128 to 127.

Line 16 illustrates the simplicity of translating an int into a 
float. Simply assign it the new value and the system will do the 
proper conversion.  When converting from float to int however, 
there is an added complication.  Since there may be a fractional 
part of the floating point number, the system must decide what to 
do with it.  By definition, it will truncate it and throw away 
the fractional part.

This program produces no output, and we haven't covered a way to 
print out char and float type variables, so you can't really get 

                                                         Page 4-3

                      Chapter 4 - Assignment and Logical Compares

in to this program and play with the results.  The next program 
will cover these topics for you.

Be sure to compile and run this program after you are sure you 
understand it completely.  Note that, once again, the compiler 
may issue warnings about type conversions when compiling this 
program.  They can be ignored because of the small values we are 
using to illustrate the various type conversions.


LOTS OF VARIABLE TYPES
-----------------------------------------------------------------
Load the file LOTTYPES.C and display it on       ================
your screen.  This file contains nearly every       LOTTYPES.C
standard simple data type available in the       ================
programming language C.  There are other 
types, but they are the compound types (ie - arrays and 
structures) that we will cover in due time.

Observe the file.  First we define a simple int, followed by a 
long int which has a range of -2147483648 to 2147483647 with most 
C compilers, and requires four bytes of storage.  Next we have a 
short int which has a range that is identical to that for the int 
variable, namely -32768 to 32767 and requires two bytes of 
storage.  The unsigned is next and is defined as the same size as 
the int but with no sign.  The unsigned then will cover a range 
of 0 to 65535.  It should be pointed out that when the long, 
short, or unsigned is desired, the int is optional and is left 
out by most experienced programmers.  We have already covered the 
char and the float, which leaves only the double.

The double is a floating point number but covers a greater range 
than the float and has more significant digits for more precise 
calculations.  It also requires more memory to store a value than 
the simple float.  The double in most C compilers covers a range 
of 1.7E-308 to 1.7E+308, contains 15 significant digits, and uses 
8 bytes of memory to store a single value.

Note that other compounding of types can be done such as long 
unsigned int, unsigned char, etc.  Check your documentation for a 
complete list of variable types.

Another diversion is in order at this point.  Your compiler 
probably has no provision for floating point math, only double 
floating point math.  It will promote a float to a double before 
doing calculations and therefore only one math library will be 
needed.  Of course, this is transparent to you, so you don't need 
to worry about it.  Because of this, you may think that it would 
be best to simply define every floating point variable as double, 
since they are promoted before use in any calculations, but that 
may not be a good idea.  A float variable requires 4 bytes of 
storage and a double requires 8 bytes of storage, so if you have 
a large volume of floating point data to store, the double will 

                                                         Page 4-4

                      Chapter 4 - Assignment and Logical Compares

obviously require much more memory.  If you don't need the 
additional range or significant digits, you should use the float 
type rather than the double.

After defining the data types in the program under consideration, 
a numerical value is assigned to each of the defined variables in 
order to demonstrate the means of outputting each to the monitor.


SOME LATE ADDITIONS
-----------------------------------------------------------------
As any programming language evolves, additional constructs are 
added to fill some previously overlooked need.  Two new keywords 
have been added to C with the release of the ANSI-C standard.  
They are not illustrated in example programs, but they will be 
discussed here.  The two new keywords are const and volatile and 
are used to tell the compiler that variables of these types will 
need special consideration.  A constant is declared with the 
const keyword and declares a value that will never be changed by 
either the program or the system itself.  If you inadvertently 
try to modify an entity defined as a const, the compiler will 
generate an error.  This is an indication to you that something 
is wrong.  Declaring an entity as const allows the optimizer to 
do a better job which could make your program run a little 
faster.  Since constants can never have a value assigned to them 
in the executable part of the program, they must always be 
initialized.

If volatile is used, it declares a value that may be changed by 
the program but it may also be changed by some outside influence 
such as a clock update pulse incrementing the stored value.  This 
prevents the optimizer from getting too ambitious and optimizing 
away something that it thinks will never be changed.


Examples of use in declaring constants of these two types are 
given as;

       const int index1 = 2;
       const index2 = 6;
       const float big_value = 126.4;
       volatile const int index3 = 12;
       volatile int index4;


THE CONVERSION CHARACTERS
-----------------------------------------------------------------
Following is a list of some of the conversion characters and the 
way they are used in the printf() statement.  A complete list of 
all of the conversion characters should be included with the 
documentation for your compiler.



                                                         Page 4-5

                      Chapter 4 - Assignment and Logical Compares

     d     decimal notation
     i     decimal notation (new ANSI standard extension)
     o     octal notation
     x     hexadecimal notation
     u     unsigned notation
     c     character notation
     s     string notation
     f     floating point notation

Each of these is used following a percent sign to indicate the 
type of output conversion desired.  The following fields may be 
added between those two characters.

     -     left justification in its field
     (n)   a number specifying minimum field width
     .     to separate n from m
     (m)   significant fractional digits for a float
     l     to indicate a long
     
These are all used in the examples which are included in the 
program named LOTTYPES.C, with the exception of the string 
notation which will be covered later in this tutorial.  Lines 31 
through 33 illustrate how to set the field width to a desired 
width, and lines 37 and 38 illustrate how to set the field width 
under program control.  This is not part of the original 
definition of C, but it is included in the ANSI standard and has 
become part of the C language.  The field width for the float 
type output in lines 41 through 45 should be self explanatory.  
Compile and run this program to see what effect the various 
fields have on the output.

You now have the ability to display any of the data fields in 
the previous programs and it would be to your advantage to go 
back and see if you can display some of the fields anyway you 
desire.


COMBINING THE VARIOUS TYPES
-----------------------------------------------------------------
Examine the file named COMBINE.C for examples     ===============
of combining variables of the various types in       COMBINE.C
a program.  Many times it is necessary to         ===============
multiply an int type variable times a float 
type variable and C allows this by giving a strict set of rules 
it will follow in order to do such combinations.

Five variables of three different types are declared in lines 4 
through 6, and three of them are initialized so we have some data 
to work with.  Line 8 gives an example of adding an int variable 
to a float variable and assigning the result to a char type 
variable.  The cast is used to control the type addition and is 
indicated by putting the desired type in front of the variable as 
shown.  This forces each of the two variables to the character 

                                                         Page 4-6

                      Chapter 4 - Assignment and Logical Compares

type prior to doing the addition.  In some cases, when the cast 
is used, the actual bit patterns must be modified internally in 
order to do the type coercion.  Lines 9 through 11 perform the 
same operation by using different kinds of type casting to 
achieve the final result.

Lines 13 through 15 illustrate the use of the cast to multiply 
two float variables.  In two of the cases the intermediate 
results are cast to the int type, with the result being cast back 
to the float type.  The observant student will notice that all 
three lines will not necessarily produce the same result.

Be sure to compile and execute this program.


LOGICAL COMPARES
-----------------------------------------------------------------
Load and view the file named COMPARES.C for      ================
many examples of compare statements in C.  We       COMPARES.C
begin by defining and initializing nine          ================
variables to use in the following compare 
statements.  This method of variable initialization is new to you 
and can be used to initialize variables when they are defined.

The first group of compare statements represents the simplest 
kinds of compares because they simply compare two variables.  
Either variable could be replaced with a constant and still be a 
valid compare, but two variables is the general case.  The first 
compare checks to see if the value of x is equal to the value of 
y and it uses the double equal sign for the comparison.  A single 
equal sign could be used here but it would have a different 
meaning as we will see shortly.  The second comparison checks to 
see if the current value of x is greater than the current value 
of z.  

The third compare introduces the not operator, the exclamation, 
which can be used to invert the result of any logical compare.  
The fourth checks for the value of b less than or equal to the 
value of c, and the last checks for the value of r not equal to 
the value of s.  As we learned in the last chapter, if the result 
of the compare is true, the statement following the if clause 
will be executed and the results are given in the comments.  

Note that "less than" and "greater than or equal to" are also 
available, but are not illustrated here.

It would be well to mention the different format used for the if 
statement in this example program.  A carriage return is not 
required as a statement separator and by putting the conditional 
clause on the same line as the if, it adds to the readability of 
the overall program in this case.



                                                         Page 4-7

                      Chapter 4 - Assignment and Logical Compares

MORE COMPARES
-----------------------------------------------------------------
The compares in the second group are a bit more involved.  
Starting with the first compare, we find a rather strange looking 
set of conditions in the parentheses.  To understand this we must 
understand just what a true or false is in the C language.  A 
false is defined as a value of zero, and true is defined as any 
non-zero value.  Any integer or character type of variable can be 
used for the result of a true/false test, or the result can be an 
implied integer or character.

Look at the first compare of the second group of compare 
statements.  The conditional expression "r != s" will evaluate as 
a true since the value of r was set to 0.0 in line 13, so the 
result of the compare will be a non-zero value.  With most C 
compilers, it would always be set to a 1, but you could get in 
trouble if you wrote a program that depended on it being 1 in all 
cases because the compiler writer is permitted to use any non-
zero value.  Good programming practice would be to not use the 
resulting 1 in any calculations.  Even though the two variables 
that are compared are float variables, the logical result will be 
of type int.  There is no explicit variable to which it will be 
assigned so the result of the compare is an implied int.  Finally, 
the resulting number, probably 1 in this case, is assigned to the 
integer variable x.  If double equal signs were used, the phantom 
value, namely 1, would be compared to the value of x, but since 
the single equal sign is used, the value 1 is simply assigned to 
the variable named x, as though the statement were not in 
parentheses.  Finally, since the result of the assignment in the 
parentheses was non-zero, the entire expression is evaluated as 
true, and z is assigned the value of 1000.  Thus we accomplished 
two things in this statement, we assigned x a new value, probably 
1, and we assigned z the value of 1000.  We covered a lot in this 
statement so you may wish to review it before going on.  The 
important things to remember are the values that define true and 
false, and the fact that several things can be assigned in a 
conditional statement.  The value assigned to the variable x was 
probably a 1, but remember that the only requirement is that it 
is nonzero. 

The example in line 20 should help clear up some of the above in 
your mind.  In this example, x is assigned the value of y, and 
since the result is 11, the condition is non-zero, which is true, 
and the variable z is assigned 222.

The third example of the second group in line 21, compares the 
value of x to zero.  If the result is true, meaning that if x is 
not zero, then z is assigned the value of 333, which it will be.  
The last example in this group illustrates the same concept, 
since the result will be true if x is non-zero.  The compare to 
zero in line 21 is not actually needed and the result of the 
compare is true.  The third and fourth examples of this group are 
therefore identical.

                                                         Page 4-8

                      Chapter 4 - Assignment and Logical Compares

ADDITIONAL COMPARE CONCEPTS
-----------------------------------------------------------------
The third group of compares will introduce some additional 
concepts, namely the logical "and" and the logical "or" 
operators.  We assign the value of 77 to the three integer 
variables simply to get started again with some defined values.  
The first compare of the third group contains the new control &&, 
which is the logical "and" which results in a true if both sides 
of the and are true.  The entire statement reads, if x equals y 
and if x equals 77 then the result is true.  Since this is true, 
the variable z is set equal to 33.

The next compare in this group introduces the || operator which 
is the logical "or" operator which results in a true if either 
side of the "or" is true.  The statement reads, if x is greater 
than y or if z is greater than 12 then the result is true.  Since 
z is greater than 12, it doesn't matter if x is greater than y or 
not, because only one of the two conditions must be true for the 
result to be true.  The result is true, so therefore z will be 
assigned the value of 22.


LOGICAL EVALUATION (SHORT CIRCUIT)
-----------------------------------------------------------------
When a compound expression is evaluated, the evaluation proceeds 
from left to right and as soon as the result of the outcome is 
assured, evaluation stops.  Therefore, in the case of an "and" 
evaluation, when one of the terms evaluates to false, evaluation 
is discontinued because additional true terms cannot make the 
result ever become true.  In the case of an "or" evaluation, if 
any of the terms is found to be true, evaluation stops because it 
will be impossible for additional terms to cause the result to be 
false.  In the case of additionally nested terms, the above rules 
will be applied to each of the nested levels.  This is called 
short-circuit evaluation since the remaining terms are not 
evaluated.


PRECEDENCE OF OPERATORS
-----------------------------------------------------------------
The question will come up concerning the precedence of operators.  
Which operators are evaluated first and which last?  There are 
many rules about this topic, but I would suggest that you don't 
worry about it at this point.  Instead, use lots of parentheses 
to group variables, constants, and operators in a way meaningful 
to you.  Parentheses always have the highest precedence and will 
remove any question of which operations will be done first in any 
particular statement.

Going on to the next example in group three in line 29, we find 
three simple variables used in the conditional part of the 
compare.  Since all three are non-zero, all three are true, and 
therefore the "and" of the three variables is true, leading to 

                                                         Page 4-9

                      Chapter 4 - Assignment and Logical Compares

the result being true, and z is assigned the value of 11.  Note 
that since the variables, r, s, and t are float type variables, 
they could not be used this way, but they could each be compared 
to zero and the same type of expression could be used as that 
used in line 29.

Continuing on to line 30 we find three assignment statements in 
the compare part of the if statement.  If you understood the 
above discussion, you should have no difficulty understanding 
that the three variables are assigned their respective new 
values, and the result of all three are non-zero, leading to a 
resulting value of true. 


THIS IS A TRICK, BE CAREFUL
-----------------------------------------------------------------
The last example of the third group contains a bit of a trick, 
but since we have covered it above, it is nothing new to you.  
Notice that the first part of the compare evaluates to false.  
The remaining parts of the compare are not evaluated, because it 
is a logical "and" so it will definitely be resolved as a false 
because the first term is false.  If the program was dependent on 
the value of y being set to 3 in the next part of the compare, it 
will fail because evaluation will cease following the false found 
in the first term.  Likewise, the variable named z will not be 
set to 4, and the variable r will not be changed.  This is 
because C uses short circuit evaluation as discussed earlier.


POTENTIAL PROBLEM AREAS
-----------------------------------------------------------------
The last group of compares illustrate three possibilities for 
getting into a bit of trouble.  All three have the common result 
that the variable z will not get set to the desired value, but 
for different reasons.  In line 37, the compare evaluates as true, 
but the semicolon following the second parentheses terminates the 
if clause, and the assignment statement involving z is always 
executed as the next statement.  The if therefore has no effect 
because of the misplaced semicolon.  This is actually a null 
statement and is legal in C.

The statement in line 38 is much more straightforward because the 
variable x will always be equal to itself, therefore the 
inequality will never be true, and the entire statement will 
never do a thing, but is wasted effort.  The statement in line 39 
will always assign 0 to x and the compare will therefore always 
be false, never executing the conditional part of the if 
statement. 

The conditional statement is extremely important and must be 
thoroughly understood to write efficient C programs.  If any part 
of this discussion is unclear in your mind, restudy it until you 
are confident that you understand it thoroughly before proceeding 

                                                        Page 4-10

                      Chapter 4 - Assignment and Logical Compares

onward.  Compile and run this program.  Add some printout to see 
the results of some of the operations.


THE CRYPTIC PART OF C
-----------------------------------------------------------------
There are three constructs used in C that make    ===============
no sense at all when first encountered because       CRYPTIC.C
they are not intuitive, but they greatly          ===============
increase the efficiency of the compiled code 
and are used extensively by experienced C programmers.  You should 
therefore be exposed to them and learn to use them because they 
will appear in most, if not all, of the programs you see in the 
publications.  Load and examine the file named CRYPTIC.C for 
examples of the three new constructs.  In this program, some 
variables are defined and initialized in the same statements for 
use later.  The statement in line 8 simply adds 1 to the value 
of x, and should come as no surprise to you.  The next two 
statements also add one to the value of x, but it is not 
intuitive that this is what happens.  It is simply by definition 
that this is true. Therefore, by definition of the C language, a 
double plus sign either before or after a variable increments 
that variable by 1.  Additionally, if the plus signs are before 
the variable, the variable is incremented before it is used, and 
if the plus signs are after the variable, the variable is used, 
then incremented.  In line 11, the value of y is assigned to the 
variable z, then y is incremented because the plus signs are 
after the variable y.  In the last statement of the incrementing 
group of example statements, line 12, the value of y is 
incremented then its value is assigned to the variable z.  To use 
the proper terminology, line 9 uses the postincrement operator 
and line 10 uses the preincrement operator.

The next group of statements illustrate decrementing a variable 
by one.  The definition works exactly the same way for 
decrementing as it does for incrementing.  If the minus signs are 
before the variable, the variable is decremented, then used, and 
if the minus signs are after the variable, the variable is used, 
then decremented.  The proper terminology is the postdecrement 
operator and the predecrement operator.


THE CRYPTIC ARITHMETIC OPERATOR
-----------------------------------------------------------------
Another useful but cryptic operator is the arithmetic operator.  
This operator is used to modify any variable by some constant 
value.  The statement in line 23 adds 12 to the value of the 
variable a.  The statement in line 24 does the same, but once 
again, it is not intuitive that they are the same.  Any of the 
four basic functions of arithmetic, +, -, *, or /, can be handled 
in this way, by putting the function desired in front of the 
equal sign and eliminating the second reference to the variable 
name.  It should be noted that the expression on the right side 

                                                        Page 4-11

                      Chapter 4 - Assignment and Logical Compares

of the arithmetic operator can be any valid expression, the 
examples are kept simple for your introduction to this new 
operator. 

Just like the incrementing and decrementing operators, the 
arithmetic operator is used extensively by experienced C 
programmers and it would pay you well to understand it 
thoroughly.


THE CONDITIONAL EXPRESSION
-----------------------------------------------------------------
The conditional expression is just as cryptic as the last two, 
but once again it is very useful so it would pay you to 
understand it.  It consists of three expressions within 
parentheses separated by a question mark and a colon.  The 
expression prior to the question mark is evaluated to determine 
if it is true or false.  If it is true, the expression between 
the question mark and the colon is evaluated, and if the compare 
expression is not true, the expression following the colon is 
evaluated.  The result of the evaluation is used for the 
assignment as illustrated in line 30.  The final result is 
identical to that of an if statement with an else clause.  This 
is illustrated by the example in lines 32 through 35 of this 
group of statements.  The conditional expression has the added 
advantage of more compact code that will compile to fewer machine 
instructions in the final program.

Lines 37 and 38 of this example program are given to illustrate a 
very compact way to assign the greater of the two variables a or 
b to c, and to assign the lessor of the same two variables to c.  
Notice how efficient the code is in these two examples.


TO BE CRYPTIC OR NOT TO BE CRYPTIC
-----------------------------------------------------------------
Several students of C have stated that they didn't like these 
three cryptic constructs and that they would simply never use 
them.  This will be fine if they never have to read anybody 
else's program, or use any other programs within their own.  I 
have found many functions that I wished to use within a program 
but needed a small modification to use it, requiring me to 
understand another person's code.  It would therefore be to your 
advantage to learn these new constructs, and use them. They will 
be used in the remainder of this tutorial, so you will be 
constantly exposed to them.

This has been a long chapter but it contained important material 
to get you started in using C.  In the next chapter, we will go 
on to the building blocks of C, the functions.  At that point, 
you will have enough of the basic materials to allow you to begin 
writing meaningful programs.


                                                        Page 4-12

                      Chapter 4 - Assignment and Logical Compares

STYLE ISSUES
-----------------------------------------------------------------
We have no specific issues of style in this chapter other than 
some of the coding styles illustrated in the example programs.  
Most of these programs are very nontypical of real C programs 
because there is never a need to list all of the possible 
compares in a real program, for example.  You can use the example 
programs as a guide to good style even though they are not real 
programs.


WHAT IS AN l-value AND AN r-value?
-----------------------------------------------------------------
You will sometimes see a reference to an l-value or a r-value in 
writings about C or in the documentation for your C compiler.  
Every variable has a r-value which is defined as the actual value 
stored in the variable, and it also has an l-value which is 
defined as its address, or the name of the variable.  Therefore, 
the variable depicted graphically in figure 4-1 has an l-value of 
index, and the r-value of 137 since 137 is the value stored in 
the variable at this time.

The definition for this variable would be given as follows;

     int index = 137;


PROGRAMMING EXERCISES
-----------------------------------------------------------------
1.  Write a program that will count from 1 to 12 and print the 
    count, and its square, for each count.
        1       1
        2       4
        3       9   etc.

2.  Write a program that counts from 1 to 12 and prints the count 
    and its inversion to 5 decimal places for each count. This 
    will require a floating point number.
        1       1.00000
        2        .50000
        3        .33333
        4        .25000
        etc.

3.  Write a program that will count from 1 to 100 and print only 
    those values between 32 and 39, one to a line.  Use the 
    incrementing operator for this program.







                                                        Page 4-13
