COP-4338, Programming III Lectures
Note: Links will not be alive until a day or two before class.
- May 10, 12, and 17: C++ Basics, arrays, strings, files, pointers, reference variables
- Simple C++, and compiling functions
- vector class.
- resizing and push_back
- string class.
- Parameter passing: call by constant reference.
- new and delete
- Reference variables
- May 19 and 24: Classes
- Classes: interfaces, member functions, visibility
- Separation of interface and implementation
- Default parameters
- Scope :: operator
- ifndef/endif and separate compilation
- Const and non-const methods
- Implicit type conversions
- Explicit constructors
- Initializer lists
- Static members
- Operator overloading
- The big three: destructor, operator= and copy constructor
- Constant and reference data member
- Linked data structures
- Aliasing and this
- Example: The Rational class
- Reference return types and operator
- May 26 and 31: Inheritance
- Implementing a derived class
- Defaults for the Big Three in the derived class
- Protected members
- Static vs. dynamic binding
- virtual keyword
- The virtual destructor
- Various C++ differences from Java
- June 2: Templates
- Why templates
- Function templates
- Class templates: interface
- Illustration of the MemoryCell class
- Specifying the requirements of the template type
- Class templates: implementation
- Separate compilation issues
- A Set class (uncommented):
(the last file is for separate compilation of templates).
- An LSet (linked list version) class (uncommented):
- Function Objects
- Reference return types
- June 7 and 9: STL
- Pointer variables and their relation to primitive arrays
- Primitive strings
- STL Basic ideas
- Lists vs Vectors
- The Pair pattern
- Sets and maps
- The concordance example
- String streams
- June 14 and 16: Programming in C
- June 28: Exam #1 C++ and C
- June 21: The Object class, Reflection, and the Proxy Pattern
- Object class PDF slides
- Reflection PDF slides
- Illustration of the correct way to override
equals, hashcode, toString,
- Illustration of using reflection to invoke main
- Using accessible fields to get private data
- Illustration of the proxy pattern.
Shows generation by hand, generation by using Java 1.3 dynamic proxies,
and an approximation of what
the dynamic proxy is actually producing for you behind the scenes
- June 23, 30, July 5: Threads and Synchronization
- PDF slides
- Illustrates basics of getting threads to run:
- Illustrates threads corrupting data:
- Series of examples using an Account.
Some threads do deposits, some do withdraws on shared account.
- Two examples with multiple monitors
- Static methods have different monitors than instance methods:
- July 7 and 12: Networking
- July 21: Exam #2: Reflection, Threading, Networking
- July 14 and 19: Serialization
- July 26 and 28: Garbage Collection
- Java Developer Connection Article
shows that soft references don't stay around for a long time.
shows a factory class that hands out Foo objects
(from a pre-allocated pool),
but requires that the client release the objects back to the pool.
shows a factory class that hands out Foo objects,
but does not require that the client release the objects.
Instead it uses weak references to detect orphaned Foo objects,
and reclaims those orphans for the pool.
- August 2 and 4: JNI
- August 4: Review
- August 9: Exam #3: Threading, Networking, Serialization, Garbage Collection
- August 11: TBA