CPSC 225, Spring 2003                       Information about the Final Exam
----------------------------------------------------------------------------

   The final exam for this course is scheduled at 1:30 PM on Tuesday, May 6.
You can expect the exam to be about six pages long.   The exam is cumulative,
with some concentration on material that has been covered since the last
in-class test.  About 50% of the exam will cover new material.  If you need
copies of the information sheets for the three in-class tests, you can find
them on-line at our class web site, http://math.hws.edu/eck/cs225/.

My office hours for the end of term are as follows:

                   Thursday, April 24, 10:00--11:55
                   Friday,   May 2,    11:00--12:00 and 1:30--3:00
                   Saturday, May 3,    12:00--1:25
                   Monday,   May 5,    11:00--3:00
                   Tuesday,  May 6,    12:00--1:25
                   
Here are some important terms and ideas that we have covered since the
third test:

    one-parameter constructors as implicit type conversion
    copy constructors
    operator overloading
    friend functions
    overloading an operator as a member function
    functions that return a reference
    the difference between initialization and assignment
    overloading the [] operator
    overloading the assignment operator
    in-line functions and in-class function definitions
    the ":" notation for initializing member variables in a constructor
    the special variable "this"
    inheritance
    derived classes and base classes
    creating a derived class of an existing class
    polymorphism
    virtual functions
    abstract classes and pure virtual functions
    calling the inherited version of a member function using ::
    calling a constructor from a base class in a derived class constructor
    expression trees
    finding the value of an expression tree 
    templates and the "template<class T>" notation
    template functions
    using a template function
    template classes
    using a template class
    stacks:  the push(x), pop(), and isEmpty() operations
    representing a stack as a linked list
    postfix expressions
    using a stack to evaluate a postfix expression
    queues:  the enqueue(), dequeue(), and isEmpty() operations
    representing a queue as a linked list with head and tail pointers
    using stacks and queues instead of recursion