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.

Answer 3

You should store pointers (smart pointers :) preferably) to Entity instances in the first place. Vector is reallocating when inserting so your objects are sliced even before calling the getter method.

Return type for getter method should be also a pointer or a reference so you'll be able to make that polimorphic call.

Answer 4

You should use a pure virtual function for this.

class Entity
{
public:
    virtual void draw() = 0;
};

Then call the draw function from your object, and you should also use pointers to your objects.

Answer 5

As a rule of thumb, you should always use reference semantics (i.e. access objects through pointers or references) instead of value semantics when dealing with objects you intend to use polymorphically.

To ensure safety in this manner, it is wise to make the base class of all your polymorphic types noncopyable by creating a private copy constructor and assignment operator. This will effectively prevent slicing as the code will simply fail to complile if value semantics are used by mistake.