Virtual Constructors

• I don't think that this is in the book.
• But here is a reference at isocpp.org.
  • I think this is a valid source as this is the C++ standard committee.
  • One of the authors of the FAQ is Stroustrup.
• My problem.
  • I abstracted a board element to be a RoomT.
  • This has a vector (should be map, but ...) of Action names a pointer to an EncounterT that "implements" that action.
    • This is the ActionT.
    • And even if we used a map we would have the same problem.
  • I need this to be a pointer so I get polymorphism out of the EncounterT.
• The problem is the copy constructor for the ActionT.
  • This is needed by the vector when adding a room to the vector.
  • This needs to make a copy of a pointer data.
    • But it is a polymorphic pointer.
    • So I can't just allocate a new one, I need to allocate a new one of the right type.
  • You could build a nasty, not-maintainable

    • if (dynamic_cast ...)
         ptr = new type 1
      else if (dynamic_cast ...)
         new type 1
      ... 

    • But this requires ActionT to know about ALL of the classes of EncounterT, and that is bad
• My original solution was to build a vector of RoomT *
  • And rely on shallow copy and hope no one misused it.
  • But then I had to delete the pointers by hand when the program ended.
  • IE as in the last example program.
  • And I was using more pointers.
  • AND IT WAS NOT CLEAN.
• What we really need is a constructor that will build the proper instance
  • AKA a virtual constructor.
  • But C++ doesn't have these
    See the FAQ, but "What is a "virtual constructor"? An idiom that allows you to do something that C++ doesn't directly support."
  • The solution is simple.
    • Add a virtual Clone() method to the polymorphic class.
    • This returns a pointer to the individual class referenced.
    • The example from the FAQ:

      class Shape {
      public:
        virtual ~Shape() { }                 // A virtual destructor
        virtual void draw() = 0;             // A pure virtual function
        virtual void move() = 0;
        // ...
        virtual Shape* clone()  const = 0;   // Uses the copy constructor
        virtual Shape* create() const = 0;   // Uses the default constructor
      };
      
      class Circle : public Shape {
      public:
        Circle* clone()  const;   // Covariant Return Types; see below
        Circle* create() const;   // Covariant Return Types; see below
        // ...
      };
      
      Circle* Circle::clone()  const { return new Circle(*this); }
      Circle* Circle::create() const { return new Circle();      }
              

    • Note, each derived class must implement a Clone.
    • But this is just following the above pattern.
  • And I have to eat my words from the last set of notes.
    • On 371 he discusses overloading a method's return type.
      • This is really only allowed if the new return type is pointer in the hierarchy.
      • Which is what we have here!
  • On a side note, I may be able to overcome this with move operators.
    • But I have insufficient knowledge of these right now.