Thread: Problem with Polymorphism

Alright, here's the problem.

I need to make a copy of an instance of a derived class by only referring to its base class. To illustrate this problem, let me provide some code.

Code:

//Base ordnance class - to be inherited by other ordnance objects
class Ordnance{

    //Virtual methods go here
    public:

        virtual void initialize(float fXPos, float fYPos, float fAz){
            std::cout << "Program shouldn't be getting here!" << std::endl;
        }//endfunction

        ....

};//class

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//Bolt class - a weapon type that extends the Ordnance class
class Bolt : public Ordnance{

    //Overriding functions
    public:

        void initialize(float fXPos, float fYPos, float fAz){
            std::cout << "This is where the program SHOULD go!" << std::endl;
        }//endfunction

    ...

};//class

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//Weapon type installed into Turret
class Weapon{
...

    public:

        //Constructor
        Weapon(Ordnance ordnance){
            this -> ordnance = ordnance;
        }//endconstructor

        void fire(float fXPos, float fYPos, float fAz){

            //Create a copy of the ordnance using the automatic copy constructor
            //and add it to the universal object system.
            Ordnance *newOrd = new Ordnance(ordnance);
            newOrd -> initialize(fXPos, fYPos, fAz);
            objects.registerNewObject(newOrd);

            //The problem is above; I think that declaring the derived class - which
            //should be of type Bolt - as an Ordnance type somehow casts it...how
            //can I work around this?

    private:

        //Copy of ordnance type
        Ordnance ordnance;

};//class

...

Bolt plasmaBolt;
Weapon weap(plasmaBolt);
weap.fire(0.0f, 0.0f, 0.0f);

The output gives:


"Program shouldn't be getting here!"


Instead of,


"This is where the program SHOULD go!"


How can I prevent the Bolt from being turned into an Ordnance type? (If this is indeed the problem) Thanks!

- Aramil

Indeed, instead of:

Code:

virtual void initialize(float fXPos, float fYPos, float fAz) {
    std::cout << "Program shouldn't be getting here!" << std::endl;
}

You should just write:

Code:

virtual void initialize(float fXPos, float fYPos, float fAz) = 0;

Of course, you would then be unable to store an Ordnance member, but doing that was wrong to begin with since it would result in type slicing, where despite passing an object of a derived class type, the derived class aspects of the object is sliced away and only what is of the base class remains. It is this type slicing behaviour that caused the Ordnance initialize member function to be called instead of the Bolt initialize member function.

The solution to this is what tabstop pointed out, i.e., store a (smart) pointer to Ordnance, so type slicing will not occur and polymorphism would work as expected.

From what I see, you want to write something along these lines:

Code:

// Abstract base ordnance class
class Ordnance {
public:
    virtual void initialize(float fXPos, float fYPos, float fAz) = 0;
    virtual ~Ordnance() {}
    virtual Ordnance* clone() const = 0;
};

//Bolt class - a weapon type
class Bolt : public Ordnance {
public:
    //Overriding functions
    void initialize(float fXPos, float fYPos, float fAz) {
        std::cout << "This is where the program SHOULD go!" << std::endl;
    }

    Bolt* clone() const {
        return new Bolt;
    }
};

//Weapon type installed into Turret
class Weapon{
public:
    Weapon(const Ordnance* ordnance) : ordnance(ordnance) {}

    void fire(float fXPos, float fYPos, float fAz) {
        Ordnance* current_ordnance = ordnance->clone();
        current_ordnance->initialize(fXPos, fYPos, fAz);
        objects.registerNewObject(current_ordnance);
    }
private:
    Ordnance* ordnance; // Associated ordnance.
};

Note that you should delete current_ordnance or wrap it in a std::auto_ptr if the objects subsystem does not delete it. Alternatively, consider using std::tr1::shared_ptr and thus avoid explicitly having to delete it in both fire() and from the objects subsystem.

Now, from what I see, the Weapon class does not have ownership, in terms of composition, of its Ordnance. Therefore, you can write:

Code:

Bolt plasmaBolt;
Weapon weap(&plasmaBolt);
weap.fire(0.0f, 0.0f, 0.0f);

In case you were not aware, Bolt::clone() overrides Ordnance::clone() even though the return types are different, due to the concept of covariant return types: since a Bolt is-a Ordnance by public inheritance, the overriding clone() virtual function may return a Bolt* instead of an Ordnance*.

Note that I would consider it a good idea to explicitly add virtual to all the virtual functions, even if the base class's function is virtual. It's not required that the derived function also be explcitly virtual if the base class's is, but it may avoid confusion.

As you can see, it returns a pointer copy of itself. This was necessary because the Bolt class obviously had other members (damage, speed, size, etc.) that need to be copied.

Yes, that is a correct fix.