Final Review
 Final Exam: Thursday Dec 13th, 2001 at 8:30 pm in SS-111, the regular classroom.
1

 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

 When we declare a variable: o space in memory is set aside to hold that data type o
That space is associated with the variable name o
Visualization of the declaration int meatballs ; meatballs
FE07
Final Review 3

 Use all uppercase for symbolic constants ( #define )
Example: PI (#define PI 3.14159 )
 Function names follow the same rules as variables
Final Review 4

 C is case sensitive o
It matters whether something is upper or lower case o
Example: area is different than Area which is different than AREA
Final Review 5

 Predefined types in C
 Integers o int, long int, short int
 Floating point o float, double
 Characters o char
Final Review 6

 auto
 case
 const break char continue
 default do
 double else
 enum extern

 float goto for if int register short signed sizeof long return struct typedef static switch union unsigned void volatile while
Final Review 7

Final Review
AREA
3D
Last-Chance x_yt3 num$ lucky*** area_under_the_curve num45
#values pi
%done
8

Name
Final Review
Addition
Subtraction -
+
Multiplication *
Division /
Modulus %
Operator Example num1 + num2 initial - spent fathoms * 6 sum / count m % n
9

 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

 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

Final Review
=
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.
Evaluated last, right to left.
12

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

 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

 All programs can be written in terms of only 3 control structures o
The sequence structure
– Unless otherwise directed, the statements are executed in the order in which they are written.
o
The selection structure
– Used to choose among alternative courses of action
Final Review o
The repetitive structure
– Allows that an action is to be repeated while some condition remains true.
15

}
{ if ( condition is “true” ) statement(s)
Final Review
}
{ if ( value = = 0 ) printf (“The value you entered was zero\n”);
16

Final Review
{ if ( value = = 0 ) printf (“The value you entered was zero\n”);
}
{
} else printf (“You didn’t enter a zero\n”);
17

Final Review
}
{ 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);
18

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

Final Review children = 10 ;
}
{ cookies = 1024 ; while ( children > 0 ) children = children - 1; cookies = cookies / 2 ;
20

 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

 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

Final Review
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
23

 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 Review change a type for a calculation.
24

Final Review
}
{ 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) ;
25

 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

 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 Review and count is 4.
27

 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

 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;
Final Review
They do the same thing. Either of these statements change the value of count by subtracting one from it.
29



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
Final Review
} for ( i = 1; i < 11; i++)
{ initialization test modification
30

{ for (i = 0; i < 11 ; i++) printf (“%d”, i);
} printf (“\n”);
Final Review 31

{ 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

 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

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

{
#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

 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

{
#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 (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


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 are used for combining condition


&& is AND
|| is OR if ( (x > 5) && (y < 6) ) if ( (z == 0) || (x > 10) )
 ! is NOT if (! (bob >42) )
Final Review 42

Final Review
}
{ if (grade == ‘D’ || grade == ‘F’) printf (“See you next semester!\n”);
43

( )
++ -- ! + (unary) - (unary) (type)
* / %
+ (addition) - (subtraction)
< <= > >=
== !=
&&
||
= += -= *= /= %=
, (comma) 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
Final Review 44

#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

}
{ void PrintMessage (int counter); main ( ) int num; printf (“Enter an integer: “); scanf (“%d”, &num);
PrintMessage (num); one argument matches the one of type int formal parameter of type int
{ void PrintMessage (int counter)
{ int i; for (i = 0; i < counter; i++) printf (“Have a nice day\n\n”);
}
}
Final Review 46

Final Review
}
#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;
47


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 Type
Final Review float double long double int long int
%f
%f
%Lf
%d
%ld unsigned int %u unsigned long int %lu shortint char
%hd
%c printf scanf conversion conversion
%f
%lf
%Lf
%d
%ld
%u
%lu
%hd
%c
49

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

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

 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

 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 2 6 9 3
0 1 2 3 4
53

 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

 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 ;
Final Review would set every element of the 100 element array, rolls, to 0.
55

 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

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

 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

}
#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 ] );
Final Review output array[0] = 0 array[1] = 1 array[2] = 2 array[3] = 3
}
/*******************************************
{
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;
}
{ for ( i = 0; i < numElems; i++) array [i] = i;
59

 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] or temper is passed.
 Example on page 230 of text.
Final Review 60

Final Review
 A common use of multiple subscripted arrays is to represent tables of values consisting of information arranged in rows + columns.
 For example: a [ 2 ] [ 3 ] row column
61

} void printArray ( int a [ ] [ 3 ] , int SIZE_R , int SIZE_C )
{
……
…..
 When we receive a single-subscripted array as an argument to a function, the array brackets are empty in the functions parameter list.
 The first subscript of a multiple-subscripted array is not required either, but all subsequent subscripts are required
Final Review 62