Chapter 10 Clean up

• There is too much in chapter 10 for us to complete.
  • We might have reached the deep end of the pool, but there is much more.
• Up casting and down casting.
  • The direction refers to direction on the tree we are casting
  • Upcasting: cast a derived class to something up the tree
  • Downcasting: cast a parent to something dervied.
  • Upcasting: Ok as long as you cast a reference or a pointer.
  • Downcastng: generally discouraged, but use a dynamic_cast when it happens.
  • See simpleDemo.cpp for dynamic_cast examples.
• Pure virtual methods

  • class BaseT {
       public:
           virtual someType Method(params) = 0;
           ...
    }; 

  • This creates a pure virtual method in a abstract base class.
  • We are forcing a method with a specific interface to be implemented, but we don't want to declare the method here.
  • Think about our square classes.
    • Should we add the Cost method to our base square?
    • What if we have no idea how to implement the base function?
    • Think about a move function for a generic animal class.
      • Some will walk
      • Some will swim
      • Some will fly
      • What should the base animal do?
    • This is a good place for a pure virtual function.
  • Pure virtual functions must be implemented in derived classes at some point.
  • Any class with a pure virtual function (abstract class) can not be created.
• Inheariting from multiple classes

  • class BirdDogT : public BirdT, public DogT {
    }; 

  • If BirdT and DogT are distinct (no common function names) no problem.
  • If there are common function names, the compiler will have an error.
    • Assume both have an eat function

    • BirdDogT::Eat() {
          if(I am a bird today) {
              BirdT::Eat();
          } else {
              DogT::Eat();
          }
      }
                   

  • This becomes worse if the parent classes are derived from the same base class.
    • The derived class with have two base classes instances.