CSIB

CSIB final: 12:45 - 3:00 p.m.	Thur.	May 9, BOW 207 (note the change from regular classroom)
Post exam consultation: 10am-12pm, Fri May 10, MSB 356 (my office)


SUGGESTED STUDYING APPROACH

- slides alone are not sufficient for adequate exam preparation: they
  are just an outline. However, only material that is on the slides
  will be on the exam.

- use slides as a guide. Read the relevant chapters in the
  textbook. Review examples we studied in class. Review your labs,
  especially if you had a lot of help and are not sure about the
  code. If necessary, re-code important portions again.  Come back to
  slides to make sure you are clear on all the material. Pay attention
  to terms definitions (they are usually shown italics in slides). Make sure
  you can define terms.


TOPICS (not an exhaustive list)

* structures - name and purpose of an aggregate construct
  structure variables, member variables, assigning structures
  passing structure as a parameter, complex structures, arrays
  of structures, arrays as member variables of a structure

* classes - purpose, advantages over structures, public/private
  members, inline/outside function definition, mutators/accessors,
  constructors, constructor overloading and default constructor,
  friend functions, static constants

* pointers - definition and usage, reference and dereference
  operators, pointers and constants, array names and pointers,
  null/loose pointer, pointers to objects (arrow operator), pointer
  arithmetic, passing pointers by value and by reference, returning
  pointers

* dynamic memory allocation - static/dynamic/automatic variables, heap
  and stack, new and delete operators, allocation for basic types, for
  arrays, for objects, memory leak problem

  allocation of objects with dynamic members: the big three
  (destructor, copy constructor, assignment overloading); memory leak
  problem for assignment overloading, protection against
  self-assignment, implementing stackability

* vectors - advantages over (raw) arrays, declaring, adding/removing
  element, comparing/assigning vectors, determining size, accessing
  first and last element, passing by value/reference returning,
  iterators, functions begin() and end(), iterator arithmetic, using
  iterators to insert, erase elements, iterator invalidation, finding
  element in a vector, sorting vector, typedef


* multidimensional arrays - reasons for use, declaring,
  usage with loops, passing to functions,

  vectors of vectors - declaring, accessing elements, ragged (jagged) array,
  changing rows and columns in an individual row


* exception handling - purpose, try/catch block, type parameter in
           throw/catch. Semantics of throwing exceptions. Throwing
           objects. Catching exceptions thrown inside
           functions. Rethrowing exceptions. Standard exceptions

* diagrams - purpose, structural vs. behavioral diagrams, class
  	   diagrams: aggregation, multiplicity relation, member
  	   visibility; object diagrams: difference from class
  	   diagrams; use case diagrams: actors, use cases, system
  	   boundary; state diagrams: initial/final state, state,
  	   transitions


* recursion: purpose, specifics of solving a task recursively,
  	    function definition vs. invocation. Specifics of recursive
  	    function definition; stopping case, infinite
  	    recursion/stack overflow; iteration vs. recursion


NOT COVERED

* namespaces: name collision; defining; resolving name declared in
  namespace; importing individual names, importing all names
  advantages/disadvantages, standard namespace


* file input/output
       streams: declaring, connecting to a file
       reading from a file, reading in a loop
       error checking on opening


* Unix/Linux issues, subversion
* Visual Studio-specific concepts