CPSC230 Spring 2004
Final Review

The final will be comprehensive concentrating on the areas that I have mentioned as most important to CPSC230 (classes and functions) and areas in which you have not been tested: arrays and file streams. There will be at least one question from every chapter that we have covered. It may be helpful for you to review your first two tests and the first two test reviews, test1 review and test2 review. The test will consist of mostly problem-solving. You will write some C++ and be asked to read some C++ and say what it does.

On this and every test there will be:

• At least one problem directly from the book
• At least one problem in which you write a function
• At least one problem in which you trace through a program or a portion of a program. You will be asked the value of variables at particular points in the code or what the program outputs or both.
• Several problems that contain incorrect C++ that you must fix
• Several problems in which you write prototypes (here is some function prototype practice) and here is some file, struct, class, and array practice. It will be helpful for you to write not only the prototypes, but also the function definition and function calls for these functions to give you help studying files, structs, classes and arrays.

The test will cover these topics:

1. Chapter 1, Writing a C++ program, sections 1.20-1.25.
   Specific topics:
   
   • Be able to write and evaluate (i.e., calculate the answer) mathematical expressions with ints and floats. Know *, / (integer and floating point division), % (which works only with integers), +, and -. Be able to write and evaluate mixed-mode expressions (involving both floating point and integer arithmetic). Know operator precedence.
   • Be able to write and understand assignment, cin, and cout statements.
   • Be able to write and understand the general structure of a C++ program. Be able to write and to trace through a C++ program.
   • Know that objects are of a class and not built-in types like int and char. Understand what a function call using dot notation means.
   • Understand and know how to write comments, declare variables, declare constants, write include compiler directives,
   • know what the types int, char, bool, double and float are for, what variable types are in general, and the difference among all of these.
   • Be able to determine the input, process, and output of a program, and of a function.
2. Chapter 2, if statements and loops (while and for), sections 2.3-2.15, 2.19, 2.20.
   If statements:Be able to write and trace through:
   • logical expressions containing relational operators only and those containing both relational and logical operators
   • a simple if statement
   • an if-else statement
   • compound statements with an if clause or an else clause or both
   • nested if and if-else statements

   Be able to write and evaluate (i.e., say whether the expression it true or false) the following:

   • logical expressions using any of the relational operators
   • logical expressions using !, && and ||

   while Loops: Be able to write and trace through (i.e., follow an already written loop):

   • that averages numbers,
   • that finds the maximum value of a number,
   • that counts values,
   • that sums numbers,
   • that counts how many times you go through a loop.

   Be able to write and trace through and know when to use:

   • a sentinel-controlled loop,
   • a count-controlled loop,
   • a validation loop.
   • Be able to write a for loop, trace a for loop, and understand each of its parts (initialization, condition, increment, body).
   • pre and post increment and decrement and assignment operators.
     Be able to write and understand how to use the operators: ++ (pre and post increment), -- (pre and post decrement), +=, -=, *=, and /=.
3. Chapter 3, functions. sections 3.1-3.7, 3.9, 3.15, 3.17, 3.20, 3.21 (or 11.2)
   Specific topics:
   
   • Know what function templates are and how to use them.
   • Know how to write and trace through/explain prototypes, function calls, and function definitions for functions that:
     
     • return no value and have no parameters,
     • return no value and have one or more input parameters
     • return a value and have no parameters,
     • return a value and have one or more input parameters.
     • have reference parameters Be able to write individual functions and entire programs that use value and reference parameters. Be able to trace through a program that uses value and reference parameters. Be able to determine when to use value and when to use reference based on an English description of what should happen in the C++ code.
4. Chapter 4, Arrays. sections 4.1-4.6.
   Specific topics:
   Know how to:
   • declare integer, char, and float arrays
   • know how to handle arrays in which all slots are not used
   • know the difference between char arrays treated as strings and other kinds of arrays
   • know how to read and write arrays (both arrays in general and char arrays being treated as strings)
   • Know how to access individual elements in an array
   • Know to write a loop to process each individual element in an array
   • know how to sum the values in an array
   • Know how to pass arrays as parameters (know how the function call, function prototype, and function header work). Know that arrays are passed (as if) by reference with no &, and that arrays that are input parameters should use const.
   • Know how to pass individual elements as parameters
   Practice: To get practice with arrays, I suggest the following exercises in the back of Chapter 4: 4.2,4.3,4.5a-c,4.8,4.13a-c,4.21

5. Chapter 6, Structs and Classes. sections 6.1-6.17, 7.1, 7.2
   Specific topics:
   Know how to:
   • Define a struct, declare a variable of a struct type, access individual fields in a struct, pass structs as parameters, pass individual fields as parameters
   • Understand and be able to use hierarchical structs with embedded arrays and classes
   • define a class, including using public and private appropriately.
   • make a header file with a class definition and #include ifndef to prevent the class definition from being included twice
   • know what constructors and destructors are and how to use them
   • know how to make an implementation file and how to use the scope resolution operator to make the function definitions in the implementation file member functions
   • Know how to use classes in a client program and how to use the dot notation.
   • Know how to classes as parameters (which by default are passed by value; instead, they should generally be passed by reference (which, like all types except arrays requires an '&') using const if the class or struct is an input parameter).
   Practice: To get practice with structs and classes, I suggest the following exercises in the back of Chapter 6: 6.1 (ignore the -> operator that is for pointers, which you'll cover in 231 and are not responsible for now); 6.2a; 6.6, 6.12. Also, I have put the fraction class definition, implementation file, and client program that we wrote in class in the Sample Code section of the 230 web page.

6. Chapter 12 and 14, File streams. sections 12.4, 12.6-12.8, 14.1-14.6
   • Know when and how to use get and getline including getline that is used for string objects.
   • Know when and how to use setw, showpoint, fixed, and understand other manipulators.
   • Be able to declare ifstream and ofstreams, and associate a disk file with a stream object (i.e., ifstream in("myinputfile") );
   • Know how to read in values from an input file
   • Know how to write and format output stream files
   • know how to check for end of file (using either while(!in.eof()) or while (in >> invalue) where in is the ifstream name and invalue is the variable into which data is being read).
   • Know how to check to make sure a file is there.
   • Know how to close a file.
   • Know how to write a program that uses input and/or output file streams.
   To practice this, write and test a program that reads in numbers from a file, sums them, averages them, finds the max and min, and counts how many there are, and write the answers to an output file.