Classes

• We will go back and take a more formal look at classes.
  • This is chapter 12.
  • You should read the entire chapter.
• You will not be a master of classes.
  • Truly learning object oriented programming takes a while.
  • But you will know the basics.
• Classes are how c++ implements an abstract data type
  • A data type whose properties (domain and operations) are specified independently of any particular implementation.
• We will use a WordListT for our data type for quite a while.
  • This is a list of WordT, (or words and frequency)
  • This enforces that only one instance of each word can be present in the list.
  • The user can
    • Add a word to the list. This will either insert a new word or increase the word count for an existing word.
    • Sort the list alphabetically based on the word.
    • Get the size of the list.
    • Iterate through the list.
      • FirstWord sets a placeholder to the first word in the list.
      • GetCurrentWord returns a WordT for the current word
        • Or the default WordT if the placeholder is not pointing to a valid word.
      • NextWord moves the place holder to the next word in the list, or one past the last word if it is currently at the last word.
        • This returns a bool indicating if it is pointing to a valid word or not.
      • The following code will iterate through the list

      • void PrintArray(WordListT & words){
            WordT tmp;
        
            words.FirstWord();
        
            tmp = words.CurrentWord();
            while (words.NextWord()) {
                cout << setw(20) << tmp.GetWord() << setw(4)
                     << tmp.GetCount() << endl;
                tmp = words.CurrentWord();
            }
        
            return;
        } 

      • This may seem like a strange function but trust me.
  • 
    • Notice the pointer between the two classes.
    • The hollow diamond indicates one of the "has a" relationships.
    • In this case a WordListT has a WordT
    • This is called an aggregation.
    • It indicates that a WordT can exist without a WordListT.
    • Think a pond has a frog, but the frog may exist without a pond.
    • The other type is a composition
    • It indicates that a WordT can not exist without a WordListT.
    • Think a frog has a hear, but the heart can not exist outside of the frog.
• In the next iteration we will
  • Build this based on a static array.
  • Then we will build a dynamic array
  • Then we will build a linked list.
  • But since we will implement this as an ADT, we will not need to change the program that uses it.
  • It should get "better" each iteration.
• The power of an ADT is that you can do just that.
  • Change the underlying implementation without changing the client code.