Identifying Classes

• Know how to apply the Abbott & Booch Nouns approach for object identifiication.
• Understand how to eliminate false objects.

Identifying Responsibilities & Attributes

• Know how to apply the Lee & Tepenhart approach to identify & eliminate (false) attributes.
• Understand how to use the Abbott & Booch Verbs approach for service identifiication. .

Class Design Notations: (NO QUESTIONS per se, but you may have to draw or read and interpret a diagram)

C++ Classes

• Understand how to use and implement class constructors and destructors.
• Be able to trace and understand code employing C++ classes.
• Know when objects are created and destroyed.
• Understand how limited scope and access are achieved using const and parameter passing mechanisms in member functions.
• Be able to over-load constructors to achieve flexible object creation and initialization: default arguments, explicit constructor invocation for initialization.

Object Communication & Behavior

• Identify static and dynamic behaviors.
• Be able to trace and understand code that communicates with objects and using objects.
• Know when to apply the different object communication mechanisms.
• Understand passing object parameter mechanisms: by copy versus by identity.

Objects and Memory

• Know the different scopes and lifetimes and how they apply to objects.
• Be able to identify automatic and dynamic object instantiation.
• Understand how to dynamically allocate and deallocate objects.
• Know the problems associated with dynamic objects: aliases, memory leaks and dangling pointers.

Object Copies

• Identify shallow and deep object copies.
• Understand how to solve the shallow copy problem.
• Know when copy constructors and assignment overload operator functions are automatically invoked.

Association (knows_a relationships)

• Know how to create an association - handles: pointers (and references).
• Be able to diagram (and interpret) class association diagrams.
• Be able to label and implement static / dynamic and uni- / bi- directional associations.

Aggregation (has_a relationships)

• Know how to create an aggregation: encapsulation, pointers.
• Be able to diagram (and interpret) class aggregation diagrams.
• Understand lifetime relationships between aggregated objects.
• Know how the execution of aggregated constructors is performed: (class declaration).
• Be able to label and implement static and dynamic aggregation.

Composition

• Know how to distinguish between association and aggregation.
• Identify when association and aggregation should be used.
• Be able to trace the instrumentation of constructors/destructors in a composed class relationship.
  • Constructor execution: inside-out.
  • Destructor execution: outside-in.

Exceptions

• Be able to trace the throwing and catching of exceptions.
• Understand the affects of a thrown exception on the execution stack.
• Know how execution continues after a caught exception.
• Understand the purpose and consequences of the catch all clause: catch (...) { }.

Inheritance and Polymorphism (is_a_kind_of relationships)

• Know the terminology of inheritance/polymorphism.
• Be able to diagram (and interpret) class hierarchy inheritance/polymorphism diagrams.
• Understand the access mechanisms between a base class and derived class through public inheritance.
• Know when constructors/destructors in a inheritance class hierarchy class are automatically executed.
• Be able to implement function over-riding and function extension in a derived class.
• Know the difference and implication of:
  • Up-casting / widening (base class <-- derived-class)
  • Down-casting / narrowing (derived class <-- base class)
• Understand how to use virtual methods to setup dynamic binding.
• Be able to determine when method invocation is due to static or dynamic binding.
  • Both implicit (this ->) and explicit dynamic binding.
  • Both static/dynamic virtual function invocation.
• Know when and why destructors should be virtual.
• Recognize abstract classes: (pure virtual methods).