312-174
Exam 1 Topics
Spring 2000
Exam date: Thursday, 24 Feb 2000, 6:30-8:30 PM, Williams 202.
This exam will consist of short answer questions. Some questions will be
theoretical in nature, eg "What is the difference between a requirement and
a specification", some are mathematical, eg "give the big-oh time of the
following function", and some are practical, eg "write a class that ...."
some questions will require you to write code. The code does not have to
be perfect (I won't compile your answer!), but must be conceptually correct.
For example, forgetting to declare a loop variable is not important, but
looping through the correct number of times is important.
The exam will cover chapters 1-4 of the Dale book and labs 1, 3, 4, and 5 of
the Roberge book. You are responsible for all of the material in the book
chapters and in the labs unless I explicitly exempt material below.
The topics covered on this exam are listed below.
Chapter 1:
- Quality Software. Goals of quality software.
- Requirements and specifications.
- Abstraction, information hiding.
- Functional decomposition (also caled top-down design).
- Object-oriented design.
- Verification (program fulfills its specifications)
- Testing, debugging, test plans.
- Validation (program fulfills its intended purpose).
- Assertions, preconditions and postconditions.
- Unit testing, black box testing (covering input values),
clear box testing (covering program paths).
- Planning for debugging.
- Stubs (for top-down testing) vs drives (for bottom-up testing).
- Top-down vs bottom-up testing.
Chapter 2:
- Data abstaction. Data encapsulation. Abstract Data types.
- Data structures.
- ADT operator categories and what they do: contructors, transformers
(or mutators), observers, iterators.
- Composite types (such as structs).
- One and two-dimensional arrays. Passing arrays as parameters. Know
how to pass multi-dimensional arrays as paramters.
- Classes and the difference between classes and structs and when
each should be used.
- Polymorphism, overloading, binding time (static vs dynamic).
- Inheritance.
Chapter 3:
- Lists as given in the book and as done in lab. Array implementation.
- Generic data types; what they are, how to make them using either a class
or templates.
- Know both sorted and unsorted lists. Be able to implement the member functions
of both classes using arrays.
- Know the binary search algorithm and how to determine its running time (ie, its
"big-O" time). Be able to determine the running time of similar algorithms.
- Big-O notation. Know how to determine this for all of the functions that we
have used in class or lab and for similar functions.
- Know what class constructors and destructors are and how to implement them.
- Know what overloading is and how to use it in C++.
Chapter 4:
- Know how stacks are implemented using both arrays (as in the book) and
dynamically (as in lab).
- Know how to use stacks in an application (as in the in-lab exercise).
- Know how to use templates.
- Know how to use pointers. Be able to use pointers to implement data
structures (such as stack). Know how arrays and pointers are related and be
able to use pointer arithmetic to iterate through arrays.
- You are only responsible for material up to page 218 in chapter 4. You are
not responsible for queues.
Return to Student Pages
Return to John Barr's Home Page
Last Modified: 17 February 2000
THIS PAGE MAINTAINED BY:
John Barr, Ithaca College