C++ Overriding Methods

Question

I can't figure out what is up with this.

I have a Scene class that has a vector of Entities and allows you to add and get Entities from the scene:

class Scene {
    private:
        // -- PRIVATE DATA ------
        vector<Entity> entityList;
    public:
        // -- STRUCTORS ---------
        Scene();
        // -- PUBLIC METHODS ----
        void addEntity(Entity); // Add entity to list
        Entity getEntity(int); // Get entity from list
        int entityCount();
};

My Entity class is as follows (output is for testing):

class Entity {
    public:
        virtual void draw() { cout << "No" << endl; };
};

And then I have a Polygon class that inherits from Entity:

class Polygon: public Entity
{
    private:
        // -- PRIVATE DATA ------
        vector<Point2D> vertexList; // List of vertices
    public:
        // -- STRUCTORS ---------
        Polygon() {}; // Default constructor
        Polygon(vector<Point2D>); // Declare polygon by points
        // -- PUBLIC METHODS ----
        int vertexCount(); // Return number of vertices
        void addVertex(Point2D); // Add vertex
        void draw() { cout << "Yes" << endl; }; // Draw polygon
        // -- ACCESSORS ---------
        Point2D getVertex(int); // Return vertex
};

As you can see, it has a draw() method that should override the draw() method it inherits from the Entity class.

But it doesn't. When using the following code:

scene->getEntity(0).draw();

where entity 0 is a Polygon (or at least should be), it prints "No" from the parent method (as though it's not a Polygon, just an Entity). In fact, it doesn't seem to let me call any methods unique to Polygon without getting:

'some method name' : is not a member of 'Entity'

So any idea what's up?

Thanks for the help.

UPDATE:

So I've implemented the code given in the first answer, but I'm not sure how to add my polygon to the list. Something like this?

const tr1::shared_ptr<Entity>& poly = new Polygon;
poly->addVertex(Point2D(100,100));
poly->addVertex(Point2D(100,200));
poly->addVertex(Point2D(200,200));
poly->addVertex(Point2D(200,100));
scene->addEntity(poly);

I'm just not used to this shared_ptr business.

Answer 1

I think that you need to post your calling code, but the essentially problem is this.

You have a concrete class Polygon deriving from another concrete class Entity. Your addEntity and getEntity functions take and return an Entity by value so if you try to pass in or retrieve an Entity, you will copy only the Entity part of that object (slicing it) and the information about the derived part of the object will be lost.

In addition you have a vector of Entity, which is a vector of base class objects, so you have no way of storing anything other than the base type of object.

If you need to have a collection of a mixed type of objects, but all derived from Entity, you may need to use dynamically created objects and some sort of smart pointer such as a tr1::shared_ptr or a boost::shared_ptr.

E.g.

class Scene {
    private:
        // -- PRIVATE DATA ------
        vector< std::tr1::shared_ptr<Entity> > entityList;
    public:
        // -- STRUCTORS ---------
        Scene();
        // -- PUBLIC METHODS ----
        void addEntity( const std::tr1::shared_ptr<Entity>& ); // Add entity to list
        const std::tr1::shared_ptr<Entity> getEntity(int); // Get entity from list
        int entityCount();
};

Edit

Your updated calling code is essentially correct, although using a local const reference to a shared pointer is a bit obscure.

I'd probably go with something like:

std::tr1::shared_ptr<Polygon> poly( new Polygon );
poly->addVertex(Point2D(100,100));
poly->addVertex(Point2D(100,200));
poly->addVertex(Point2D(200,200));
poly->addVertex(Point2D(200,100));
scene->addEntity(poly);

Answer 2

chollida's comment is correct: you're pushing an object of type Polygon into a memory location meant for types Entity, and running into what is called slicing. The extra 'Polygon' info gets sliced away and all you have left is the Entity.

You should store pointers (or references, if possible) to base classes in these situations.