CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Hints for Assignment 1

• A linked list consists of a sequence of elements linked together by pointers.

• In a singly-linked list, each element has two parts:
  
  1. the data being stored in that element,
  2. a pointer to the next element.
  • If there is no "next element", the "next" pointer is set to NULL.

  • We must have a pointer that points to the first element in the list (the head of the list).

  • Example:
    

  • Note that we can only move forward in a single-linked list. We cannot move backward.

  • When traversing the list, you would use another pointer that moves through the list.

  • To find the end of the list, you can either traverse the list to find it or maintain a pointer which always points to the last element in the list.

• If we want to be able to move backward in a list, we can use a doubly-linked list.
  • In a doubly-linked list, each element has three parts:
    
    1. the data being stored in that element,
    2. a pointer to the next element,
    3. a pointer to the previous element.

  • Example:
    

  • In addition to the pointer which points to the head of the list, you may want to keep a pointer which points to the last element in the list.

• There are three problems to solve when working with linked lists:
  1. How do we add an element?
  2. How do we find an element? Or traverse the list?
  3. How do we remove an element? Or all elements?

  It is sometimes easier to work out solutions to these problems by drawing diagrams like those above and working it out on paper.

• To see how to access member of a dynamically-allocated structure, read pages 138-140 in Prata.

Scope and Lifetime (continued)

• (continued)
  • Static duration items exist for the entire duration of the program.
    • Example:

         void f(int x) {
            static int count = 0;
            count++;
            cout << "f has been called " << count << " times.";
            ...
            return;
         }
      	            

      count exists for the duration of the program, although its scope is just the function f.

  • Persistent items exist longer than the duration of the program. These items must be stored in non-volatile storage (such as a disk).

• The scope of an item can be block, local, module, global, or system.
  • Block items are defined in a block and are accessible only within that block. Blocks are delimited by { }.

  • Local items are defined at the outermost level of a function. Local items may be automatic or static in duration.

  • Module items are defined outside of any function, and are accessible from anywhere in one source file.

  • Global items have a scope which includes more than one (possibly all) source files.

  • System items are accessible from other programs.
    • Example: files, environment variables.

Return to lecture notes index

Lectures