Copyright © 2016
Robert W. Hasker

Note 8: C++ with Class

Ch. 4 of textbook

Classes in C++

• Goal: more detail
• Stroustrup: "the central language feature of C++ is the class" [p. 48].
  • core idea: if have a useful concept, try to represent it as a class
  • advantage: make the idea explicit rather than just a concept in your head
  • example: any array can be a stack, but making it a class makes that explicit
    • And no longer have to remember if have top-of-stack or count of items!
  • Stroustrup: all features of C++ (beyond fundamental types, operators, and statements) "exist to help define better classes or use them more conveniently"
• Goal is to support concrete and abstract classes, support hierarchies

Concrete Types

• See class complex on p. 49
• Goal: make it look like a built-in type: complex impedance;
• no pointers, so no requirement for memory management
  • Appropriate when identity (uniqueness) is not important
• efficiency very important: compilers can generate code with no overhead: no extra data, no unseen work
  • When a method is defined in the class, it's inline
  • inlined methods: replacing the function call by the body of the function (or method)
• const methods: do not change the state of the object
  • important information for the compiler
• constructor with no arguments: default constructor
• operator+: defined outside of the class
  • see definitions on page 50
• his definition of == is dangerous!!!
  • note no need to check types - C++ type system ensures only appropriate values passed in
    • yet another case of no overhead
• caveat: be careful about defining overloaded operators
  • complex operator-(complex a, complex b) { return a += b; }

Inheritance, Abstract Types

• See sample Time class for basic inheritance
• override: declare that you are overriding a method, like @override in Java
  • That is, ensures the new method does redefine some method in the base class
• virtual: allows redefining method in subclass
  • These are often called virtual functions
  • It supports inheritance polymorphism
    • Example: a graphics image with squares, circles, etc: appling a draw operation to each would require making the draw method be virtual (in C++)
  • subclass methods must have the same argument types, return type
  • we say the subclass methods override the base class ones
• Java: all methods are virtual
• C++: can control which are virtual - desired because virtual methods do have overhead
• what is the practical reason for inheritance?

      Time *submissions[20] = { new Time(10, 22),
                                new Time(13, 45),
                                new MilTime(13, 18),
                                new MilTime(23, 0),
                                new MilTime(5, 10),
                                new Time(1, 15)
                              };
  
      ...
  
      for(int i = 0; submissions[i] != nullptr; ++i) {
        submissions[i]->print(cout);
        cout << endl;
      }
  

• ": public" in the class header: means derived from
  • If use ": private", then base class public methods are private in subclass
  • This is never a good idea - why use inheritance if not going to follow the interface defined by the base class?
    • If pass the object to to a function that takes the base class as an argument, that function can still access those base class operations that we tried to hide!
• Suppose we have public class Firefly extends Insect
  • [In what order are the constructors called?]
  • These rules are the same in C++
  • [How are arguments to Insect's constructor specified?]
  • C++ version:

        class Insect {
        public:
          Insect(std::string species);
        };
    
        class Firefly {
        public:
          Firefly(std::string species) : Insect(species) {
            // more code
          }
        };
    

Memory allocation, deallocation

• Consider

      class Student {
        string name;
        string address;
        double total_grade_points, total_credits;
        Schedule *schedule;
      public:
        Student() : schedule{new Schedule} { }
        double gpa() const { return total_grade_points / total_credits; }
        virtual void add(Course *new_course);
      };
  

  • When allocate a Student object, also allocate a Schedule object
  • delete student; - works, but doesn't reclaim the space for the schedule
    • Every new must have a corresponding delete
    • (Or the object must be able to exist until the end of the application)
  • Solution: add a "destructor":

        ~Student() { delete schedule; }
    

  • Note: add is virtual; can be redefined in subclasses
  • If add is virtual, then ~Student must be:

        virtual ~Student() { delete schedule; }
    

  • Destructor is called when exit scope as well:

        void doSomethingNice() {
          Student someStudent;
          ...
          // destructor called here
        }
    

Abstract class

    class AbstractContainer {
    public:
      virtual double& operator[](int index) = 0;
      virtual int size() = 0;
      virtual ~AbstractContainer() { }
    };  

• The = 0 syntax means the method is abstract or pure virtual
  • These methods must be redefined - cannot create an object of type AbstractContainer
  • All methods must be defined or get linker errors
    • Linker will say something like "unresolved symbol"
    • a class is abstract if it has at least one pure virtual method
  • C++ has no special keyword for "all pure virtual"
• Returning double& in operator[] means we can assign as well as use the value
  • Consider the code

       void swapFirstLast(AbstractContainer &nums) {
         int last_index = nums.size() - 1;
         assert(last_index > 0); // last_index can be 0!
         double first = nums[0];
         nums[0] = nums[last_index];
         nums[last_index] = save;
       }
    
    
       ... declare xs to be some class derived from AbstractContainer
       ... and read data into the container
       // first shall be last, last shall be first:
       swapFirstLast(xs);
    

    • nums passed by reference
    • code generated by this: equivalent to returning a pointer and then dereferencing that pointer on each access:

          double* p = &nums[0];
          *p = nums[last_index];
      

Container

• Have already seen containers in previous examples
• from ch. 4, arbitrary-size vector with destructor: see here
  • Note return by reference: double&
  • useful as both an l-value and an r-value
  • r-value: value on the right-hand-side of an assignment - the contents
  • l-value: value on left-hand-side of assigment - the address
• Usage:

      {
        int n; 
        cin >> n;
        FixedVector xs(n);
        ...
        {
          FixedVector ys(n * 2);
          ...
        } // ys destroyed here
        ...
      } // xs destroyed here
  

  • In general: destructor called at end of lifetime (usually, when leave scope)
  • if a class has a virtual function, the destructor must be virtual
    • Compiler will give warning if it is not virtual.
    • Deleting the object invokes the destructor of the derived class, that destructor will cause the base class destructor to execute
  • Constructors cannot be virtual - it makes no sense
  • What would happen if you made the constructor =0?
  • How would you make a singleton object in C++?
• Resource Acquisition Is Initialization (RAII):
  • no naked new operations associated with stack-allocated objects
  • move resource management into well-behaved abstractions
  • If you move new, delete follows
  • Applies to objects without identity; if have single instance, use pointers
• Initialization
  • Add constructor FixedVector(std::initializer_list<double>)
    • initializer_list is an STL type known to the compiler
    • This allows FixedVector v1 = {1, 2, 3, 4, 5};
    • We won't cover the details on this.

Using Abstract Classes

• Suppose we have a really large vector: megavector.h
• Initialize container to a sequence:

      void initializeUpSequence(AbstractContainer *container,
                                double start, double step) {
        double value = start;
        for(int ix = 0; ix < container->size(); ++ix) {
          (*container)[ix] = value;
          value += step;
        }
      }
  
      ...
      AbstractContainer *some_numbers = new MegaVector();
      initializeUpSequence(some_numbers, 1.0, 0.1);
      double sum = 0.0;
      for(int i = 0; i < some_numbers->size(); ++i)
        sum += (*some_numbers)[i];
  

• Note: initializeUpSequence cannot be

      void initializeUpSequence(AbstractContainer container,
      double start, double step);
  

  (with no *)
  • Get a copy of the container without the parts that make it a sequence
  • This creates an instance of an AbstractContainer, something C++ does not allow
• But can use references:

      void initializeUpSequence(AbstractContainer &container,
      double start, double step);
  

  however, the pointer version makes it more obvious that the object is on the heap

Pass-by-reference and Containers

• Consider what happens when we pass a container by value:

      double first_and_last(MegaVector nums) {
        double sum = nums[0] + nums[nums.size() - 1];
        return sum;
      }
  

• What is the big-O of

      MegaVector xs;
      ...
      double s = first_and_last(xs);
  

• Better:

      double first_and_last(MegaVector &nums) {
        double sum = nums[0] + nums[nums.size() - 1];
        return sum;
      }
  

  • Issue: no protection against accidental changes:

        double sum = (nums[0] = 0.0) + nums[nums.size() - 1];
    

• Better:

      double first_and_last(const MegaVector &nums) {
        double sum = nums[0] + nums[nums.size() - 1];
        return sum;
      }
  

  • However, need to revise class with const methods: revised_vector.h
• Other examples of using const&
  • Overloading < on students:

        bool operator<(const Student &a, const Student &b) {
          return a.name() < b.name();
        }
    

    • Avoid copying whole Student object just to compare names

Review

• Concrete types: built-in behavior
  • const methods, default constructor
  • overloading operators; inside vs. outside class
• containers
  • return by reference
  • l-value vs. r-value
  • destructor
  • RAII: Resource Acquisition Is Initialization
• override keyword
• inheritance, virtual methods
• abstract classes
• pure virtual methods