Chapter 10 overview

• What if I am writing a game that has a bunch of different types of board locations.
  • Think of a rpg like exploration game.
    • In a very simple game there might be encounter squares
    • Or trap squares
    • Or transport squares
    • ...
  • We want to store these all on a single board, so we need a common type.
  • So we implement a huge class
    • It contains an enumerated type to identify the square type.
    • And each method has a huge switch statement based on that enumerated type.

      
      vector<vector<SquareT>> board
      
      SquareT::Movememt() {
          switch (SquareType) {
              case TRAP
                 DoTrapMovement()
                 break;
              case ROAD
                 DoRoadMovement()
                 break
             ...
      }
                  

  • The C style would be to implement a bunch of different classes

    • vector<vector<void *>> board
      
      class TrapSquare{
      };
      
      class RoadSquare {
      } 

    • Then you have a mess with
      • Pointer management and getting them pointing to the correct type.
      • Repeated code, each class would potentially have large chunks of it.
• The C++/object oriented way is to use inheritance and polymorphism.
• Inheritance is a method to extend classes to behave in different ways.
  • Please note, our examples are exceedingly simple. You COULD do everything in our examples with simple classes.
  • In reality, you can do everything in machine language, the only structures you need are arrays and a stack.
• This technique will allow us to
  • Share code between classes
  • REQUIRE a common interface.
  • Build true IS-A relationships.
  • Extend a class that you might not have code for.
• Generally to do this you need a generic base class.
  • This class is the MOST GENERAL or generic
  • It contains anything common to all classes
    • A common set of functions (interface)
    • A common data storage.
  • It need not implement all of these functions, but it can.
• From this base class you develop derived classes
  • These are specializations of the base class.
  • They can use the base class members,
  • They can extend the base class members,
  • Or they can replace the base class members.
  • They can also add members.
  • You do not want to DELETE members.
• As a client, or user of the system
  • An object belongs to its own class and any base classes from which it was derived.
• Let's explore our board squares a bit.
  • The basic square has the following methods
    • EnterSquare() - the player enters the square for actions.
    • ExitSquare() - the player is done and exits the square
    • TraverseSquare() - the player wants to travel through the square

    • class BaseMapSquareT {
          public:
              BaseMapSquareT(PlayerT & );
              void EnterSquare(PlayerT &);
              void ExitSiquare(PlayerT &);
              void TraverseSquare(PlayerT &);
          private:
              int timesVisited{0};
      };
                 

    • There is more syntax, but this is a start.
  • A Market Square

    • class MarketSquareT : public BaseMaptSquareT {
           public:
              vector<StoreT>ListStores();
              void EnterSquare(PlayertT &);
           private:
               vector<StoreT>stores;
      };
                 

    • This replaces the default enter square method.
    • And provides a new method, ListStores.
    • And a new dat member
  • If a function is handed a MarketSquareT it can
    • Get a list of stores.
    • Also allow the player to enter, exit and traverse this square.
• In general, you need to pass references or pointers to classes in a hierarchy
  • These are generally passed as base class members,
  • The run time system will then figure out what member functions to call.

  • void PlayerAction(Squaret & square, PlayerT & 
            

• New access specifier
  • protected:
  • Derived classes member functions have access to parent's protected members.
  • Public and private still apply as before.
• So a derived class has the same public and protected data members and methods as the base class plus anything added.