Intro to Chapter 12

• You must read chapter 12.
• An Abstract Data Type is a data type whose properties (domain and operations) are specified independently of any particular implementation
  • Know this definition.
• But what does it mean?
  • What is the domain of the integers?
  • What are the operations?
  • How are they implemented.
• Do the same with strings.
• A major step in developing reusable, extendable, maintainable software is this concept.
  • You describe what an object is and what it does in terms of an ADT
  • When it is implemented, you then use the interface to manipulate the object.
  • If the underlying implementation changes, your code still works.
• This is the foundation for object oriented design.
  • To solve a problem, we identify the basic objects involved in the solution.
  • We implement the objects and use these to build the solution.
• This lends us to thinking in terms of the data rather than in terms of a final algorithm.
• When used correctly, this is a much more powerful tool.
• Classes
  • In c++ ADTs are represented as classes.
  • This is a tool, equivalent to a structure
    • In fact, structs and classes in C++ are essentially the same thing.
    • But more on that later.
• Let's try an example.
• Describe the ADT for a rational number class
  • What is the domain?
  • What operations can you perform on this
• When we build a class, we need to know
  • The member data, or what will our class hold?
  • The member methods (or functions) what can we do with our class?
• To declare a class
  • Declare the class
  • Implement the member functions.
• This is normally done in two files, but can be done in one.
• The most correct method is in multiple files.
  • Increased readability, reusability, maintainability, ...
• Declaration

  • class identifier {
        public:
           public member declarations;
        private:
           private member declarations;
    };
             

• public and private are access modifiers
  • This tells the compiler what has access to the data members.
• All members declared public are available to all other code
  • This is the default for a struct
  • In general, this should only be member functions, but much more on that later.
• All members declared private are only accessible within the class
  • This is the default for a class, but declare it anyway
  • The provides protection for the data members.
• Before we go on, member functions can be classified into a few classes
  • A constructor is responsible for constructing or initializing member data,
    • Or it creates an instance of the class.
    • Or it instanciates the object.
    • This sets up all of the data for the class.
    • This is why strings are empty.
  • A destructor is responsible for cleaning up when an instance of a class goes out of lifetime.
    • More on this later. (Like next chapter)
  • An observer or getter allows a user of the class to get the value of the class.
  • A transformer or setter allows the user of the class to set or change the of the class.
  • Iterators are another class, but we will not discuss them for quite a while.