UP ONE LEVEL: ENEL 315 Home Page

ENEL 315 L02 Lecture Information
Winter Session 1996

Note carefully! I will not be putting my lecture notes on line. I expect students to attend lectures. If you miss a lecture, the best way to get the lecture notes is to borrow them from a fellow student.

Lectures are listed in reverse order because readers are most likely to be looking for information about recent lectures.

The organization of material in lectures does not exactly match the organization of material in the textbooks, so when I list ``related reading'', I can't be completely precise. In some cases using the index or table of contents will help you find additional information.

Last modified: Fri Apr 12 14:17:23 MDT 1996

Week 13

Lecture #37 (Fri., April 12)
Introduction to C++ features not covered in C++, including the STL (Standard Template Library). (This material will NOT be on the exam.)
Lecture #36 (Wed., April 10)
The spiral model of S/W development. General remarks about iterative development processes.
Related reading:
  • none
    • Lecture #35 (Mon., April 8)
    Introduction to C++ language rules related to inheritance: memory organization for objects of derived class objects, rules for ctors and dtors.
    Related reading:
  • rules.cc on inheritance handout
  • certain Items in Meyers and C++ FAQs (details to follow)

    • Week 12

    Lecture #34 (Wed., April 3)
    Virtual functions, dynamic binding, pure virtual functions, abstract base classes. The Visitor class - a practical example of an ABC.
    Related reading:
  • Carrano, pages 353-372
  • Meyers, pages 117-122
  • inheritance examples handout
  • code from Lab[9] Ex E and F
  • C++ FAQs (Reserve Reading) - if you're interested in learning more about how to use inheritance
    • Lecture #33 (Mon., April 1)
    Public inheritance: the is-a relationship.
    Introduction to virtual functions and polymorphism.
    Related reading:
  • Carrano, pages 353-372
  • Meyers, pages 117-122
  • inheritance examples handout

    • Week 11

    Lecture #32 (Fri., March 29)
    Removing a node from a binary search tree.
    Efficiency of binary search tree operations.
    Related reading:
  • Carrano, pages 477-484, 493-498
    • Lecture #31 (Wed., March 27)
    Traversals of binary trees.
    Removing a node from a binary search tree. (The next lecture will say more about this topic.)
    Related reading:
  • Carrano, pages 448-451, 477-484
  • source code for Lab[9] Exercise C
    • Lecture #30 (Mon., March 25)
    Implementation of a binary search tree in C++. Details of the insert operation.
    Related reading:
  • Carrano, pages 468-477
  • source code for Lab[9] Exercise C

    • Week 10

    Lecture #29 (Fri., March 22)
    Introduction to binary search trees.
    Related reading:
  • Carrano pages 438-454
    • Lecture #28 (Wed., March 20)
    Introduction to Big O notation.
    Running times for some familiar algorithms.
    Discussion of running time for quicksort.
    Related reading:
  • Carrano pages 393-405
    • Lecture #27 (Mon., March 18)
    How the quicksort algorithm works.
    A relatively simple partitioning algorithm.
    Related reading:
  • Carrano, pages 419-429

    • Week 9

    Lecture #26 (Fri., March 15)
    Template instantiation issues.
    Global function templates.
    Related reading:
  • Point class template example (class handout)
  • Budd (Reserve Reading), Chapter 6 (lots of examples)
    • Lecture #25 (Wed., March 13)
    Introduction to class templates.
    Compiling and linking problems related to templates.
    Related reading:
  • Carrano, pages 380-383 (somewhat terse coverage)
  • Meyers, Item 18 (an example)
  • Budd (Reserve Reading), Chapter 6 (lots of examples)
    • Lecture #24 (Mon., March 11)
    Introduction to operator overloading.
    Discussion of SimCplx (simple complex number) class.
    Related reading:
  • Carrano, pages 384-386 (lame, 3 serious errors in example)
  • Meyers, Items 19 and 23 (not 22 - sorry!)
  • Stroustrup, Ch. 7 (all the details)

    • Week 8

    Lecture #23 (Fri., March 8)
    Example use of pointers to functions.
    Syntax issues related to pointers to functions.
    Related reading:
  • Pointers to Functions in C and C++ (class handout)
  • Carrano, pages A37 to A47
    • Lecture #22 (Wed., March 6)
    A bit more about queueing simulation.
    Introduction to pointers to functions.
    Related reading:
  • Pointers to Functions in C and C++ (class handout)
    • Lecture #21 (Mon., March 4)
    Singly-linked list queue inmplementation.
    Queue implementation using composition with the TwoWayList class.
    A queuing simulation problem.
    Related reading:
  • Carrano, pages 311-315, 324-327

    • Week 7

    Lecture #20 (Fri., Feb. 23)
    Unit testing and other methods for finding defects in S/W components.
    Introduction to the Queue ADT; implementation with a circular array.
    Related reading:
  • Carrano, pages 307-321
    • Lecture #19 (Wed., Feb. 21)
    Phases in the software development cycle. The waterfall model; reasons why nobody really believes in the waterfall model.
    Related reading:
  • Carrano, pages 4-12 (But note how this material doesn't exactly match my lecture.)

    • Week 6

    Lecture #18 (Fri., Feb. 16)
    A stack-based solution to the airline route search problem.
    Review: how to avoid leaking memory in assignment operators.
    Related reading:
  • Carrano, pages 281-291
    • Lecture #17 (Wed., Feb. 14)
    Array and linked-list implementations of Stacks.
    Introduction to airline route search problem.
    Related reading:
  • Carrano, pages 259-269, 281-290
    • Lecture #16 (Mon., Feb. 12)
    The interface for a Stack class.
    Use of a Stack to check for balanced parentheses and square brackets.
    Related reading:
  • Carrano, pages 249-258

    • Week 5

    Lecture #15 (Fri., Feb. 9)
    Programming details related to describing sub-arrays.
    Introduction to the stack ADT, including analogies to stacks of dinner plates.
    Related reading:
  • descriptions of Lab[4] Exercises A and B
  • Carrano, pages 249-258
    • Lecture #14 (Wed., Feb. 7)
    Using recursion to find a path through a maze.
    Related reading:
  • Carrano, pages 203-218
  • description of Lab[4] Exercise D
    • Lecture #13 (Mon., Feb. 5)
    Binary search algorithm. General remarks about recursion.
    enum types in C++.
    Related reading:
  • Carrano, Chapter 2, especially pages 81-86
  • Recursion Exercises for ENGG 333 Fall 1995

    • Week 4

    Lecture #12 (Fri., Feb. 2)
    insert_first function for doubly-linked list with dummy head node. (But I made a mistake - I forgot to put len++ in the function definition.)
    Iterators: concept, use, implementation.
    Related reading:
  • description of Lab[3] Exercise D
  • files TWList.hh and TWList.cc
    • Lecture #11 (Wed., Jan. 31)
    The Big Three (destructor, copy constructor, assignment operator).
    Overview of singly-linked lists.
    Introduction to a doubly-linked list with a dummy head node.
    Related reading:
  • Carrano, pages 150-163 and 177-184
    • Lecture #10 (Mon., Jan. 29)
    Copy constructors and assignment operators
    - examples for Lab[3] Exercise C.
    Definition of the term data structure.
    Related reading:
  • Meyers, Items 11, 15, 17 (highly recommended!)
  • Carrano, pages 104-107, 150-162

    • Week 3

    Lecture #9 (Fri., Jan. 26)
    The null pointer in C++. Why you no longer have to check for failure of new. A first try at a dynamic array class. Destructors. Why a shallow copy isn't always the right way to copy an object.
    Related reading:
  • Carrano, pages 141-149, 166-167
  • Meyers, Items 6, 11
    • Lecture #8 (Wed., Jan. 24)
    Introduction to function overloading. Introduction to use of new and delete for free store memory management.
    Related reading:
  • Meyers, Items 21, 3, 5
  • Static and Dynamic Allocation (ENGG 333 handout)
    • Lecture #7 (Mon., Jan. 22)
    PROMISES documentation for ADT operations. Comparison of classes with modules: information hiding is a common design principle. More about references in C++: refs to const things, functions returning refs.
    Related reading:
  • Chapter 9 of C++ FAQs (Reserve Reading book)
  • ENGG 333 Fall '95 Lab[6] Exercise E
  • Meyers (Effective C++) Items 21, 22, 23

    • Week 2

    Lecture #6 (Fri., Jan. 19)
    More on ADTs. The BoundedList ADT example. Policies about what should happen when an operation doesn't make sense. REQUIRES documentation for ADT operations.
    Related reading:
  • Carrano, Chapter 3
  • the file BndList.hh from Lab[1] Ex D
  • Chapter 9 of C++ FAQs (Reserve Reading book)
    • Lecture #5 (Wed., Jan. 17)
    Activation records and the this pointer.
    Definitions of the terms object, abstraction and abstract data type.
    Related reading: Memory Diagrams for C++, Part I (handout).
    Lecture #4 (Mon., Jan. 15)
    Organization of class type declarations and member function definitions. The default constructor.
    Related reading: Carrano, Chapter 3.

    Week 1

    Lecture #3 (Fri., Jan. 12)
    More on reference arguments. Built-in types in C++, including bool. Introduction to struct and class types.
    Related reading: Carrano, pages 14-20, 102-112, 120-128.
    Lecture #2 (Wed., Jan. 10)
    Introductory remarks about C++. A simple example use of iostreams. Reference arguments to functions.
    Related reading: Carrano, pages A1-A18.
    Lecture #1 (Mon., Jan. 8)
    Welcome to ENEL 315. Explanation of policies on the course outline.
    Related reading: none.

    Author's home page