void printIterativeRev(Node* list)
{
    // if the list is empty, just return
  if (!list)
    return;

    // point to the first node
  Node* head = list;

    // get length of the list
  int length = 0;
  while (head)
  {
    head = head->next;
    length++;
  }	

    // for each node in the list
  for (int i = length; i > 0; i--)
  {
    Node* previousPtr;

      // start to first node
    Node* currentPtr = list;
	
	 // go to node at position 'i'
    int position = 0;
    while (position < i)
    {
        // save pointer to previous node
      previousPtr = currentPtr;

      currentPtr = currentPtr->next;
      position++;
    }

      // print previous data    
    cout << previousPtr->data << endl;
  }
}

• Non OOP typically uses top-down design or structured design decomposing the problem into modules
• These programs are collections of interacting functions
• Before we used classes, we programmed top-down
• Top-down doesn't scale up well for large programs
• It is generally difficult to reuse code from one program to the next since the functions work directly on the data
• Object-oriented languages must provide 3 facilities
  • data abstraction
  • inheritance
  • polymorphism (dynamic binding)
• Programs written in an OO language are collections of interacting objects
• In C++, classes provide data abstraction; a class is essentially an ADT
• Client programs don't work directly on the data in an object, they "ask" the object to manipulate its own data via public member functions (methods)
• OO refers to this "asking" as "sending a message" to the object

Other OO languages use different terminology than C++. Here are some equivalents:

OOP	C++
Object	Class object or instance
Instance variable	Private data member
Method	Public member function
Message passing	Calling a public member function

Within a class, all of the data and functions are related. Within a program, classes can be related in various ways.

1. Two classes are independent of each other and have nothing in common
2. Two classes are related by inheritance
3. Two classes are related by composition

Relation by composition is called a has-a relationship.
A car has a motor.

Inheritance Example

class Time
{
  public:
    void Set(int h, int m, int s);
    void Write(void) const;
    void Increment(void);
    Time (int h, int m, int s);
    Time(void);

  private:
    int hrs;
    int mins;
    int secs;
};

enum ZoneType {EST, CST, MST, PST, EDT, CDT, MDT, PDT};

class ExtTime : public Time
{
  public:
    void Set(int h, int m, int s, ZoneType z);
    void Write(void) const;
    ExtTime(int h, int m, int s, ZoneType z);
    ExtTime(void);

  private:
    ZoneType zone;
};

Back to Outline