Lecture Notes for Computer Algorithms I

2 October 2003 - A Time ADT

Time

• Dealing with time is common and hard.

• Sounds like a good candidate for an ADT.

Time Operations

• Copy functions.

• Access functions.

• Input-output functions.

• Relational operators.

Public vs. Private

• A public ATD member is a permanent committment.

  • Changes in public ADT members can potentially break client code.

  • And it's difficult to determine if that's true.

• Reserve the right to make as many changes to an ADT as possible.

  • To fix errors, improve performance

• To preserve your ability to change an ADT, minimize the members in the interface.

Client Interface

Implementing ADTs

• An ADT implementation has

  1. an interface declaration (the what).

     unsigned get_minute() const;
     

  2. an implementation definition (the how).

     unsigned 
     time::get_minute() const {
       return minutes;
       }
     

• Interface declarations go in the .h header file.

• Implementation definitions go in the .cc source file.

• What happens if you put implementation definitions in the header file?

  • Nothing much bad, but

    • Implementation definitions are likely to change, forcing recompilations for files including the header.

    • The header file starts to get large, making compilation times longer.

Class Constructors

• Default constructors.

• Constructor functions.

• Explicit value constructors.

Name Qualifications

• The :: scope operator.

Inline Functions

ADT State

• Consider the following time state:

  t.minutes: -100
  t.hours: 25
  

  Does this look correct to you?

• Class invariants

• Pre- and post-conditions.

Default Arguments

• Const reference parameters.

Overloading Operators

• Which is better?

  1) deadline = new.add(period);
  
  2) deadline = new + period;
  

• Operator overloading lets you define time::add()() as the binary plus operator.

• It's called overloading because plus already has several meanings, and you're adding another.

• "Overloading" sounds tricky, and it is.

  • There's several nasty interactions with other C++ features, particularly type conversions.

Overloading Functions

• Consider the following:

  print_int(std::cout, i);
  print_double(std::cout, x);
  print_string(std::cout, "hello");
  print_char(std::cout, 'c');
  

  Wouldn't it be better to not have to think of all those function names?

  print(std::cout, i);
  print(std::cout, x);
  print(std::cout, "hello");
  print(std::cout, 'c');
  

• We can overloading operators; can we overload functions too?

  • Yup.

• A functon's signature is the key to overloading.

Friends

• Friends provide a mechanism for violating encapsulation.

  • A friend of class B has access to all members of class B.

• Friends are nasty. Don't use them.

Exceptions

• An exception is an extreme error condition.

  • Running out of memory is an exception, not finding a file is not.

• An exception provides an abrupt and asynchronous control transfer to an (almost) arbitrary other part of the program.

• Exceptions are nasty. Don't use them.

This page last modified on 5 October 2003.