GCO4020/CSC428 - Advanced Object Oriented Techniques In C++
Course guide

GCO4020/CSC428
Course Outline

Week 1

• Topic 1: Implementing an array class
  • Concept overview
  • Class overview
  • Using the Array class
  • Constraints on ElementType
  • The private constants of class Array
  • Accessing elements
  • Reallocating memory within an Array
  • The Array(void) constructor
  • The Array single-element constructor and copy constructor
  • The Array::Size nested class and associated Array constructors
  • The ~Array destructor
  • Finding elements in an Array
  • Checked public access to individual Array elements
  • Assigning elements to an Array
  • Appending elements to an Array
  • Removing elements from an Array
  • Comparing Arrays for equality
  • Exercises for Topic 1
• Topic 2: Proxies
  • What is a Proxy?
  • Where are Proxies Needed?
  • Implementing a Proxy for the String Class.
  • Limitations of Proxies.
  • Exercises for Topic 2
• Sidebar: Redirecting The Standard I/O Streams
  • The Problem
  • A Solution

Week 2

• Topic 3: Map Interfaces
  • What is a map?
  • Openness and closedness of maps
  • The trouble with Standard maps.
  • An explicitly access-controlled map class
  • An implicitly access-controlled map class
  • Exercises for Topic 3
• Topic 4: Self Linking Lists
  • Self-linking objects
  • The SelfLinking base template
  • The DictEntry base class
  • Why make SelfLinking a template?
  • Exercises for Topic 4
• Sidebar: Reinstating hidden base class functions
  • Oh where, oh where has my member function gone?
  • Reinstating hidden member functions.

Week 3

• Topic 5: Hiding Implementation Details
  • Why hide the implementation?
  • Hiding the implementation behind a pointer
  • Hiding the implementation behind a reference
  • Exercises for Topic 5
• Topic 6: Registries
  • Using a registry as a "virtual constructor"
  • The Creator helper class
  • The Registry class
  • Extending a Registry to perform general actions
  • The Action helper class
  • The extended Registry class
  • Exercises for Topic 6
• Sidebar: Template Constraints
  • The problem
  • Explicitly specifying template constraints
  • Using template constraints

Week 4

• Topic 7: Reference Counting
  • Why count references?
  • The structure of a reference counting system
  • The reference count class
  • The reference-counted pointer class
  • Limitations of reference counting
  • Exercises for Topic 7
• Topic 8: Wrappers
  • The "Wrapper" idiom
  • To wrap or not to wrap
  • Exercises for Topic 8
• Sidebar: Preventing Inheritance
  • Analyzing the problem
  • Virtual inheritance to the rescue
  • Generalizing Uninheritable

Week 5

• Topic 9: Envelopes and Letters
  • The Envelope/Letters concept
  • Implementing a Value class without envelope/letters
  • Implementing a Value envelope
  • Implementing letters for the Value envelope.
  • Templated letters
  • Specializing templated letters
  • Tying templated letters to the ValueEnv envelope class
  • Exercises for Topic 9
• Topic 10: Mimicking "illegal" types in unions
  • Restrictions on C++ unions
  • Avoiding union membership restrictions via mimicry
  • The MimicDiscriminator class
  • The Mimic template
  • A small matter of alignment
  • Using Mimic members in a union
  • Determining a union's active member
  • Exercises for Topic 10
• Sidebar: Preventing Implicit Conversions of Inbuilt Types
  • The problem
  • Making inbuilts explicit via a proxy
  • Generalizing the solution

Week 6

• Topic 11: Double Dispatch I
  • The problem of double dispatch
  • Double dispatch via "chained" virtual calls
  • Implementing double dispatch in the ValueLet hierarchy
  • Exercises for Topic 11
• Topic 12: Double Dispatch II
  • Decoupling new letter types
  • Triple Dispatch and Beyond
  • Exercises for Topic 12
• Sidebar: Fixing variable scopes in old-style "for" loops
  • Fixing the variable scope in a for loop.

Week 7

• Topic 13: Allocation Tracking
  • Tracking leaking dynamic memory
  • Tracking a dynamic object's origin
  • Separating the tracking of different classes
  • Exercises for Topic 13
• Topic 14: Dynamic Scopes
  • Cleaning up leaked memory at termination
  • Making clean-up more selective
  • Cleaning up dynamic memory at the end of a block
  • Using dynamic scopes
  • Exercises for Topic 14
• Sidebar: Named Loops
  • The problem of escaping nested loops
  • Named loops
  • Simulating named blocks in Standard C++
• Note: Assignment 1 (worth 50%) is due this week (Friday 14 April, noon).

Week 8

• Topic 15: Properties
  • The properties of properties
  • Implementing properties
  • Properties as members
  • Properties as objects
  • Properties as function pointers
  • Exercises for Topic 15
• Topic 16: Interprocess Objects
  • Forking and piping
  • Dup'ing and exec'ing
  • An object-based approach to process forking
  • An object-based approach to exec'ing
  • Using Subprocess objects as filters
  • Using Subprocess objects for non-determinism
  • Exercises for Topic 16
• Sidebar: Read Only Members
  • Problems with public data members
  • Read-only data members

Week 9

• Topic 17: Fallible Types
  • The virtue of "fallibility"
  • Creating a Fallible proxy - the "fallible" bit
  • Creating a Fallible proxy - the proxy bit
  • Using Fallible values
  • Chaining "fallible" operations
  • A "fallible" selection operator
  • Exercises for Topic 17
• Topic 18: Receptors
  • A base class for receptors
  • An "until" receptor class
  • A "while" receptor class
  • Delimited receptors
  • Literal receptors
  • Exercises for Topic 18
• Sidebar: "Semi-virtual" Inheritance
  • The "problem" of virtual inheritance
  • Implementing "semi-virtual" inheritance.

Week 10

• Topic 19: Persistent Objects I
  • Components of a persistence system
  • Encoding and Decoding - Binary formats
  • Encoding and Decoding - ASCII-based formats
  • Storage and Retrieval
  • The "identity" problem
  • An object-based C++ persistence model
  • Exercises for Topic 19
• Topic 20: Persistent Objects II
  • The limitations of object-based persistence
  • Pointer-based persistence
  • Trapping accesses to an object through a pointer
  • The WriteBack base class
  • The WriteBackPtr proxy
  • The WriteBackObj proxy
  • Conclusion
  • Exercises for Topic 20
• Sidebar: Promptors
  • A simple "promptor"
  • A smarter "promptor"
  • A usable "promptor"

Week 11

• Topic 21: Functors I
  • The functor concept
  • Customized ordering in an STL map
  • Unifying the WhileReceptor and UntilReceptor classes
  • A simple encoder functor
  • Exercises for Topic 21
• Topic 22: Functors II
  • Closures
  • Compositions of Functors
  • "Higher-order" Functors
  • Exercises for Topic 22
• Sidebar: Restricting access to functions
  • Restricting access to functions via friendship
  • An access-restricting class

Week 12

• Topic 23: Dataflow programming
  • The dataflow concept
  • A base class for dataflow components
  • A class for storage nodes
  • Implementing processor nodes
  • I/O nodes
  • Self-refreshing storage nodes
  • Dataflow for simulation
  • Dataflow for parallelism
  • Exercises for Topic 23
• Topic 24: Lazy Evaluation
  • The problem of temporaries
  • Minimizing expensive temporaries with lazy evaluation
  • A simple Matrix class
  • A lazy operation class
  • A lazy Matrix class
  • Re-injecting temporaries
  • Exercises for Topic 24
• Sidebar: Altering Default Parameter Values
  • Changing function parameter defaults at run-time
  • Changing functor parameter defaults at run-time
  • Detecting default arguments
• Note: Assignment 2 (worth 50%) is due this week (Friday 26 May, noon).

Last updated: Fri Feb 18 13:19:14 2000