1 Abstraction

In general, abstraction is a creative process of focusing attention on the main problems by ignoring lower-level details.

In programming, we encounter two particular kinds of abstraction:

• procedural abstraction and
• data abstraction.

Every cell in a spreadsheet has a unique name. The name has a column part and a row part.

• The row indicators are integer values starting at 1.

• The column indicators are case-insensitive strings of alphabetic characters as follows: A, B, … , Z, AA, AB, AC, … , AZ, BA, BB, … ZZ, AAA, AAB, … and so on.

• Optional $ markers may appear in front of each part to “fix” the row or column during copying.

  • Examples: A1, BC23, B$3, $A$1, $ZZZZZ2

1.2.3 Example: a book

How to describe a book?

1.2.3 Example: a book

How to describe a book?

• If we are implementing a card catalog and library checkout, it is probably enough to list the metadata, e.g., title, authors, publisher, date.

1.2.3 Example: a book

How to describe a book?

• If we are implementing a card catalog and library checkout, it is probably enough to list the metadata, e.g., title, authors, publisher, date.

• If, however, we are going to be working on a project involving the full text of the document (e.g., automatic metadata extraction and indexing), then we might need all the pages and all the text.

• If we are implementing a card catalog and library checkout, it is probably enough to list the metadata, e.g., title, authors, publisher, date.

• If, however, we are going to be working on a project involving the full text of the document (e.g., automatic metadata extraction and indexing), then we might need all the pages and all the text.

• On the other hand, if we were building bookshelves, we might need more physical attributes such as size and weight!

Any time you have an ordered sequence of data, you can imagine the need to look through it. That then leads to the concept of a position within that sequence, with notions like

• finding the first and last position,
• going forward to the next position, etc.

2.2 Examples

2.2.1 Calendar Days

Nothing in the definition of ADT that says that the interface has to be written out in a programming language.

 

UML diagrams present classes as a 3-part box: name, attributes, & operations

Calendar Days: alternative

But we can use a more programming-style interface:

 

class Day {
public:
   // Attributes
   int day;
   int month;
   int year;
   
   // Operations
   Day operator+ (int numDays);
   int operator- (Day);
   bool operator< (Day);
   bool operator== (Day);
     ⋮

or

class Day {
public:
   // Attributes
   int getDay();
   void setDay (int);
   int getMonth();
   void setMonth(int);
   int getYear();
   void setYear(int);
   
   // Operations
   Day operator+ (int numDays);
   int operator- (Day);
   bool operator< (Day);
   bool operator== (Day);
     ⋮

Either of these interfaces captures the sense of the ADT described in the diagram.

• Possible disadvantages of moving early to programming-style interfaces:
  • getting lost in language details
  • prematurely committing to those details

2.2.2 Cell Names

Here is a possible interface for our cell name abstraction.

 

class CellName
{
public:
  CellName (std::string column, int row,
            bool fixTheColumn = false,
            bool fixTheRow=false);
  //pre: column.size() > 0 && all characters in column are alphabetic
  //     row > 0

  CellName (std::string cellname);
  //pre: exists j, 0<=j<cellname.size()-1, 
  //        cellname.substr(0,j) is all alphabetic (except for a
  //             possible cellname[0]=='$')
  //        && cellname.substr(j) is all numeric (except for a
  //             possible cellname[j]=='$') with at least one non-zero
  //             digit

  CellName (unsigned columnNumber = 0, unsigned rowNumber = 0,
            bool fixTheColumn = false,
            bool fixTheRow=false);

  std::string toString() const;
  // render the entire CellName as a string

  // Get components in spreadsheet notation
  std::string getColumn() const;
  int getRow() const;

  bool isRowFixed() const;
  bool isColumnFixed() const;


  // Get components as integer indices in range 0..
  int getColumnNumber() const;
  int getRowNumber() const;


  bool operator== (const CellName& r) const
     ⋮
private:
     ⋮

Arguably, the diagram presents much the same information as the code

class Book {
public:
  Book (Author)                 // for books with single authors
  Book (Author[], int nAuthors) // for books with multiple authors

  std::string getTitle() const;
  void putTitle(std::string theTitle);

  int getNumberOfAuthors() const;

  std::string getIsBN() const;
  void putISBN(std::string id);

  Publisher getPublisher() const;
  void putPublisher(const Publisher& publ);

  AuthorPosition begin();
  AuthorPosition end();

  void addAuthor (AuthorPosition at, const Author& author);
  void removeAuthor (AuthorPosition at);

private:
  ⋮
};

• What are Author and Publisher in this interface?
  • They are simply other ADTs in this library world, and will need to have designed interfaces of their own.

• A look at our Book interface may suggest why.

  bookNumericPositions.h

  class Book {
  public:
    Book (Author)                 // for books with single authors
    Book (Author[], int nAuthors) // for books with multiple authors
  
    std::string getTitle() const;
    void putTitle(std::string theTitle);
  
    int getNumberOfAuthors() const;
  
    std::string getIsBN() const;
    void putISBN(std::string id);
  
    Publisher getPublisher() const;
    void putPublisher(const Publisher& publ);
  
    typedef int AuthorPosition;
    Author getAuthor (AuthorPosition authorNum) const;  
  
    void addAuthor (AuthorPosition at, const Author& author);
    void removeAuthor (AuthorPosition at);
  
  private:
    ⋮
  };
  

• One intuitive idea might be to simply number the authors and treat the number as a position indicator, as shown here.

  • biases implementors towards arrays/vectors
  • may lock us into inefficient solutions

C++ Iterators

The solution adapted by the C++ community is to have every ADT that is a “container” of sequences of other data to provide a special type for positions within that sequence.

• The container itself provides functions to return
  • the beginning position in the sequence and
  • the position just after the last data item in the
  (these are typically called begin() and end()

• The position ADT must provide, at a minimum:

  • A function to fetch the data item at the given position.

  • A function to advance from the current position to the next position in the sequence.

  • A function to compare two positions to see if they are the same.

A Possible Position Interface

In theory, we could satisfy this requirement with an ADT like this:

class AuthorPosition {
public:
   AuthorPosition();

   // get data at this position
   Author getData() const;

   // get the position just after this one
   AuthorPosition next() const;

   // Is this the same position as pos?
   bool operator== (const AuthorPosition& pos) const;
   bool operator!= (const AuthorPosition& pos) const;

};

which in turn would allow us to access authors like this:

void listAllAuthors(Book& b)
{
   for (AuthorPosition p = b.begin(); p != b.end(); 
        p = p.next())
     cout << "author: " << p.getData() << endl;
}

The Iterator ADT

For historical reasons (and brevity), however, C++ programmers use overloaded operators for the getData() and next() operations:

Given a container c and “positions” it and it0 somewhere within c:

We call position ADTs that conform to this patter iterators (because they let us iterate over a collection of data).

For example, we might define an iterator for authors in a book as:

class AuthorPosition {
public:
   AuthorPosition();

   // get data at this position
   Author operator*() const;

   // get a data/function member at this position
   Author* operator->() const;

   // move forward to the position just after this one
   AuthorPosition operator++();

   // Is this the same position as pos?
   bool operator== (const AuthorPosition& pos) const;
   bool operator!= (const AuthorPosition& pos) const;

};

so that code to access authors would then look like this:

void listAllAuthors(Book& b)
{
   for (AuthorPosition p = b.begin(); p != b.end(); 
        ++p)
     cout << "author: " << *p << endl;
}

Range-Based For Loops

In later years, C++ embraced the idea that iterators would be a pervasive part of typical programming style. New short-hand versions of for loops were introduced specifically to work with classes that provide iterators via the conventional interfaces.