Final Exam

Final Exam: Thursday December 15,
2005 at 8:30 pm in room MP-008, the
regular classroom. If you can not make
it to the exam tell me after class today.
Only critical excuses will be honored.
Final Review
1
Using Variables
You may declare variables in C.
 The declaration includes the data type
you need.
 Examples of variable declarations:

int meatballs ;
float area ;
Final Review
2
Declaring Variables

When we declare a variable:
o
o
o
Final Review
space in memory is set aside to hold that
data type
That space is associated with the variable
name
Visualization of the declaration
int meatballs ;
meatballs
FE07
3
Naming Conventions
(continued)

Use all uppercase for symbolic
constants ( #define )
Example: PI (#define PI 3.14159 )

Function names follow the same rules
as variables
Final Review
4
Case Sensitive

C is case sensitive
o
o
Final Review
It matters whether something is upper or
lower case
Example: area is different than Area
which is different than AREA
5
More Variables
Predefined types in C
 Integers

o

Floating point
o

int, long int, short int
float, double
Characters
o
Final Review
char
6
Keywords in C








auto
case
const
default
double
enum
float
goto
Final Review
break
char
continue
do
else
extern
for
if
int
register
short
signed
sizeof
struct
typedef
unsigned
volatile
long
return
static
switch
union
void
while
7
Which Are Legal Identifiers ?
AREA
3D
Last-Chance
x_yt3
num$
lucky***
Final Review
area_under_the_curve
num45
#values
pi
%done
8
Arithmetic Operators
Name
Operator
Addition
Subtraction
Multiplication
Division
Modulus
Final Review
+
*
/
%
Example
num1 + num2
initial - spent
fathoms * 6
sum / count
m%n
9
Modulus
%
The expression m % n yields the
remainder after m is divided by n.
 Modulus is an integer operation. - Both
operands MUST be integers.
 Examples : 17 % 5 = 2
6%3 = 0
9%2 = 1
5%8 = 5

Final Review
10
Integer Division
If both operands of a division
expression are integers, you get an
integer answer. The fractional portion
is thrown away.
 Examples :
17 / 5 = 3
4 / 3 = 1
35 / 9 = 3
 Division where one operand is a floating
point number will produce a floating
Final Review
point answer. Automatic promotion.

11
Arithmetic Operators
Rules of Operator Precedence
Operator(s)
()
Precedence & Associativity
Evaluated first. If nested innermost first. If on same
level - left to right.
* / %
Evaluated second. If many,
they are evaluated left to right
+ -
Evaluated third. If there are
several, evaluated left to right.
=
Final Review
Evaluated last, right to left.
12
Relational Operators
<
>
<=
>=
==
!=
less than
greater than
less than or equal to
grater than or equal to
is equal to
is not equal to
Relational expressions evaluate to the int
value 1 (True) or the int value 0 (False)
Final Review
All of these operators are called binary operators
because they take two expressions as operands
13
True or False

Arithmetic expressions also evaluate to
true of false.

Any expression that has a zero value is
false. ( 0 ) is False

Any expression that has a non-zero
value is true. ( 1 ) is True
Final Review
14
Structured Programming

All programs can be written in terms of
only 3 control structures
o
The sequence structure
–
o
The selection structure
–
o
Used to choose among alternative courses of
action
The repetitive structure
–
Final Review
Unless otherwise directed, the statements are
executed in the order in which they are written.
Allows that an action is to be repeated while
some condition remains true.
15
A Selection Structure
the if statement
if ( condition is “true” )
{
statement(s)
}
if ( value = = 0 )
{
printf (“The value you entered was zero\n”);
}
Final Review
16
Example of if - else
if ( value = = 0 )
{
printf (“The value you entered was zero\n”);
}
else
{
printf (“You didn’t enter a zero\n”);
}
Final Review
17
Example
if ( value = = 0 )
{
printf (“The value you entered was zero\n”);
}
else if ( value < 0 )
{
printf (“%d is negative.\n”, value);
}
else
{
printf (“%d is positive.\n”, value);
}
Final Review
18
Gotcha
int a = 2;
Final Review
if (a = 1)
{
printf (“ a is one \n”);
}
else if (a == 2)
{
printf (“ a is two \n ”);
}
else
{
printf (“ The vaue of a is %d \n”, a);
}
19
Our example while loop
children = 10 ;
cookies = 1024 ;
while ( children > 0 )
{
children = children - 1;
cookies = cookies / 2 ;
}
Final Review
20
Using a Sentinel Value
We could let the user keep entering the
grades and when he’s done enter some
special value that signals us that he’s
done.
 This special signal value is called a
sentinel value.
 We have to make sure that the value we
choose as the sentinel isn’t a legal
grade. (ie. can’t use 0 as the sentinel )

Final Review
21
The Priming Read
When we use a sentinel value to contol
a while loop, we have to get the first
value from the user before we
encounter the loop so that it will be
tested and the loop can be entered.
 This is known as a priming read.
 We have to give significant thought to
the initialization of variables, the
sentinel value and getting into the loop.

Final Review
22
Pseudocode for Using a Sentinel to
End a while Loop’s Execution
Initialize total to 0
Initialize counter to 0
Get the first grade from the user
While the grade != the sentinel value
Add grade to total
Add 1 to counter
Get the next grade (could be sentinel)
average = total / counter
Print the average
Final Review
23
The cast operator ( )
We can use a cast operator to create a
temporary value of the desired type, to
be used in a calculation.
 Does NOT change the variable’s type or
how it is stored.
 Is only good for the statement it’s in.
 Often used to avoid integer division.
 Used anytime we want to temporarily
Final Reviewchange a type for a calculation.

24
Using a Sentinel (continued)
while (grade != -1)
{
total = total + grade ;
counter = counter + 1 ;
printf (“Enter grade, -1 to end : “);
scanf (“%d”, &grade);
}
average = ( float ) total / counter ;
printf (“The average was %.2f\n”, average) ;
}
Final Review
25
Increment and Decrement Operators
The Increment Operator ++
 The Decrement Operator - Precedence - lower than (), but higher
than * / and %
 Associativity - right to left
 Increment and decrement operators can
only be applied to variables, NOT to
constants or expressions

Final Review
26
Post-Increment Operator

The position of the ++ determines WHEN the
value is incremented. If the ++ is after the
variable then the incrementing is done last.
int amount, count;
count = 3;
amount = 2 * count++;
amount gets the value of 2 * 3 or 6 and
then 1 gets added to count
 So after executing the last line, amount is 6
Final Reviewand count is 4.

27
Pre-Increment Operator

If the ++ is before the variable then the
incrementing is done first.
int amount, count;
count = 3;
amount = 2 * ++count;


1 gets added to count first, then amount gets
the value of 2 * 4 or 8
So after executing the last line, amount is 8
and count is 4.
Final Review
28
Decrement Operator
If we want to subtract one from a
variable, we can say:
count = count - 1;
 Programs can often contain statements
that decrement variables, so to save on
typing, C provides these shortcuts :
count- - ; OR - - count;
They do the same thing. Either of these
statements change the value of count
Final Review
by subtracting one from it.

29
The for loop Repetitive Structure


The for loop handles details of the counter-controlled
loop automatically
The initialization of the the loop control variable,
termination conditional test and modification are
handled in for loop structure
for ( i = 1; i < 11; i++)
{
initialization
modification
}
test
Final Review
30
A for loop that counts
from 0 to 10
for (i = 0; i < 11 ; i++)
{
printf (“%d”, i);
}
printf (“\n”);
Final Review
31
do-while example
do
{
printf (“Enter a positive number: “);
scanf (“%d”, &num);
if (num < = 0)
{
printf (“ \n That is not positive, try again \n ”);
}
} while (num <= 0);
Final Review
32
for vs while

use a for loop when your program
“knows” exactly how many times to loop

use a while loop when there is a
condition that will terminate your loop
Final Review
33
Nested for loops
Final Review
for (i = 1; i < 5; i++)
{
for (j = 1; j < 3; j+)
{
if (j % 2 = = 0)
{
printf (“O”);
}
else
{
printf (“X”);
}
}
printf (“\n”);
}
How many times is the
‘if’ statement executed?
What is the output ??
34
The char data type
The char data type holds a single
character
char ch;
 The char is held as a one-byte integer in
memory. The ASCII code is what is
actually stored, so we can use them as
characters or integers, depending on
our purpose
 Use scanf (“%c”, &ch); to input 1 char

Final Review
35
Character Example
#include <stdio.h>
main ( )
{
char ch;
printf (“Enter a character: “);
scanf (“%c”, &ch);
printf (“The value of %c is %d.\n”, ch, ch);
}
If the user entered an A the output would be
The value of A is 65.
Final Review
36
The getchar ( ) function

We can also use the getchar() function that is
found in the stdio library

The getchar ( ) function reads one charcter
from stdin and returns that character (value)

The value can then be stored in either a char
variable or an integer variable
Final Review
37
getchar () example
#include <stdio.h>
main ( )
{
char grade;
printf (“Enter a letter grade: “);
grade = getchar ( );
printf (“\nThe grade you entered was %c.\n”, grade);
}
Final Review
38
switch example
switch (day)
{
case 0: printf (“Sunday\n”);
break;
case 1: printf (“Monday\n”);
break;
case 2: printf (“Tuesday\n”);
break;
case 3: printf (“Wednesday\n”);
break;
case 4: printf (“Thursday\n”);
break;
case 5: printf (“Friday\n”);
break;
case 6: printf (“Saturday\n”);
break;
default: printf (“Error -- unexpected value for day\”);
break;
}
Final Review
39
break
The last statement of each ‘case’ in the
switch should be (99 % of the time)
break;
 The break causes program control to
jump to the right brace of the switch
 Without the break, the code flows into
the next case. This is almost never
what you want.

Final Review
40
#define EOF



getchar( ) is usually used to get characters
from a file until the “end of file” is reached
The value used to indicate the end of file
varies from system to system. It is “system
dependent”.
But, regardless of the system we’re using,
there is a #define in stdio library for EOF
Final Review
41
Logical Operators

Logical operators are used for combining
condition

&& is AND
if ( (x > 5) && (y < 6) )

||
is OR
if ( (z == 0) || (x > 10) )

!
is NOT
if (! (bob >42) )
Final Review
42
Example of ||
if (grade == ‘D’ || grade == ‘F’)
{
printf (“See you next semester!\n”);
}
Final Review
43
Operator Precedence & Associativity
()
++ -- ! + (unary) - (unary) (type)
* / %
+ (addition) - (subtraction)
< <= > >=
== !=
&&
||
= += -= *= /= %=
, (comma)
Final Review
left to right/inside-out
right to left
left to right
left to right
left ot right
left to right
left to right
left to right
right to left
right to left
44
Examining PrintMessage
#include <stdio.h>
void PrintMessage (void);
main ( )
{
PrintMessage ( );
}
void PrintMessage (void)
{
printf (“A message for you:\n\n”);
printf (“Have a Nice Day!\n”);
}
Final Review
function Prototype
function call
function header
function
body
45
Another version of
PrintMessage
void PrintMessage (int counter);
main ( )
{
int num;
printf (“Enter an integer: “);
scanf (“%d”, &num);
PrintMessage (num);
one argument
}
of type int
void PrintMessage (int counter)
{
int i;
for (i = 0; i < counter; i++)
{
printf (“Have a nice day\n\n”);
}
}
Final Review
matches the one
formal parameter
of type int
46
Using AverageTwo
#include <stdio.h>
float AverageTwo (int num1, int num2);
main ( )
{
float average;
int num1 = 5, num2 = 8;
average = AverageTwo (num1, num2);
printf (“The average of %d and %d is %f\n”, num1, num2, average);
}
float AverageTwo (int num1, int num2)
{
float average;
Promoted to float
average = (num1 + num2) / 2.0;
return average;
Final Review
}
47
Local Variables




Functions only “see” their own local variable.
This includes main ( )
The variables that are passed to the function
are matched with the formal parameters in
the order they are passed
The parameters are declarations of local
variables. The values passed are assigned to
those variables
Other local variables can be declared within
the function
Final Review
48
Data Types and
Conversion Specifiers
Data Type
float
double
long double
int
long int
unsigned int
unsigned long int
shortint
char
Final Review
printf
conversion
scanf
conversion
%f
%f
%Lf
%d
%ld
%u
%lu
%hd
%c
%f
%lf
%Lf
%d
%ld
%u
%lu
%hd
%c
49
Commonly Used Header Files
header file Contains function prototypes for
<stdio.h>
the standard input/output library functions
& information used by them
<math.h>
the math library functions
<stdlib.h>
the conversion of number to text, text to
number, memory allocation, random
numbers and other utility functions
<time.h>
maninpulating time and date
<ctype.h>
functions that test characters for certain
properties and that can convert case
others
see page 159 of text
Final Review
50
Manipulating what rand() returns




Since rand() returns unsigned integers in a large
range, we often have to manipulate the return value
to suit our purposes
Suppose we want only random numbers in the range
from 0 to 5
o num = rand () % 6
How about 1 to 6?
o num = 1 + rand( ) % 6;
How about 5 to 20?
o num = 5 + rand ( ) % 16;
Final Review
51
srand ( ) and rand ( )



The pseudo-random number generator needs
an unsigned int as it’s seed
Although it produces what appear to be
random numbers, if we use the same seed,
we get the same sequence of random
numbers
To get different random numbers each time
we run our program, we have to give a
different seed each time
Final Review
52
Array Declarations




int array [5] ;
This declaration sets aside a chunk of
memory that’s big enough to hold 5 integers.
It does not initialize those memory locations
to 0 or any other value.
Initializing an array may be done with an
array initializer, as in :
int array [5] = { 5, 2, 6, 9, 3 } ;
array
Final Review
5
0
2
1
6
2
9
3
3
4
53
Indexing Array Elements
Values of individual elements can be
found by indexing into the array. In our
example, array [0] is equal to 5 and
array [3] is equal to 9.
 The integer in square brackets is called
the subscript.
 The subscript could also be an
expression that evaluates to an integer.
 In our example, array is the name of the
Final Review
array.

54
Filling Arrays
Since many arrays are quite large,
using an array initializer is impractical.
 Large arrays are often filled using a for
loop.
for ( i = 0; i < 100; i++)
{
rolls [ i ] = 0 ;
}
would set every element of the 100
Final Review element array, rolls, to 0.

55
Using #define for array sizes

We often use the
#define to give the
sizes of arrays.
#define SSIZE 39
#define GSIZE 5
main ( )
{
int score [SSIZE] ,
gradeCounter [GSIZE] ;
}
Final Review
56
Arrays and Pointers




Final Review
The array name alone (without [ ] ) is just a
variable that contains the starting address of
the block of memory where the array is held.
A pointer is just a variable that holds an
address.
So the array name alone is a pointer to the
array.
Pointers have types. If an array is an array of
ints, then the name of that array has the type
pointer to int or int pointer.
57
Passing Arrays to Functions

The function prototype :
void FillArray ( int array[ ], int numElems);

The function definition header:
void FillArray ( int array[ ], int numElems)

The function call:
FillArray ( array, SIZE);

Final Review
Notice that we are passing only the name of
the array (an address) and that we aren’t
returning anything (the function is void)
58
Passing an Array to a Function
Example
#include <stdio.h>
#define SIZE 4
void FillArray (int array[ ], int numElems) ;
main ( )
{
int array [SIZE];
FillArray ( array, SIZE);
/* Print the elements of the array */
for ( i = 0; i < SIZE; i++)
{
printf (array[%d] = %d\n”,
i, array[ i ] );
}
}
for ( i = 0; i < numElems; i++)
{
array [i] = i;
}
}
output
Final Review
/*******************************************
FillArray is a function that will fill each
element of any integer array passed
to it with a value that is the same as
that element’s subscript.
*******************************************/
void FillArray (int array[ ],
int numElems)
{
int i;
array[0] = 0
array[1] = 1
array[2] = 2
array[3] = 3
59
Passing Arrays to Functions

If an individual element of an array such as
temper[3] is passed to a function, it is passed
by value not address. So the array is not
modified.

Not like when &temper[0]
passed.
Final Review
or temper is
60