Inheritance Confusion

Question

Alright so I've been working on a game engine, and I'm running into a problem... Currently I have a hierarchy of classes (image->animation->object) all of which have a method get_type() and I'm having this problem:

if I declare a derived class using the new keyword, or statically, I get the desired results:

object instance; cout << instance.get_type(); //returns an int value object* pointer = new(object); cout << pointer->get_type();

From the above code, the console outputs 3. The method is declared as such in object:

Image Class:

class image{ public: virtual int get_type(); }; int object::get_type(){ return 1; }

Animation Class:

class animation: public image{ public: virtual int get_type(); }; int animation::get_type(){ return 2; }

Object Class:

class object: public animation{ public: virtual int get_type(); }; int object::get_type(){ return 3; }

Now the problem arises when I do something like this:

object* t = &object(); cout << t->get_type();

The result is now 1.

If I remove the virtual keyword from the class declaration of the object class, it works as I expect (the last bit of code returns 3)

Question: how can I utilize my virtual methods from the object* pointer without using the new keyword? Reason being, I'm filling a vector with pointers to these objects and creating them as I'm adding them, so I hope to be able to do something like the following:

vector<object*> objects; //not imgs or animations for (int a = 0; a < 20; a++){ objects.push_back(&object()); }

And have any object[x]->get_type(); return the correct class type. The reason for this is an event system that I'm using in my game that needs the origination class type...

TLDR; I really stink at inheritance, can you help?

This newbie question is well asked.

sharptooth
– sharptooth

2011-08-24 05:13:58 +00:00
Commented Aug 24, 2011 at 5:13 — sharptooth
– sharptooth, Commented Aug 24, 2011 at 5:13

Greg Hewgill · Accepted Answer · 2011-08-24 05:20:16Z

This is because both the constructor and destructor have run in your code:

object* t = &object(); cout << t->get_type();

The &object() creates an (anonymous, temporary) object, immediately destructs it (because it's temporary), and then assigns the address of the now-destructed object to t. (Your compiler may warn you about this expression if you turn the warning level up high enough.)

Try creating an object that sticks around during the time you're using it:

object my_object(); object *t = &my_object; cout << t->get_type();

When you're using non-virtual functions, the type of the pointer t is used at compile time to determine which method to call. When you're using virtual functions, information inside the object is used at runtime during virtual dispatch to decide which function to call. Since your object is not correctly constructed at the time of the call (since it has already been destructed), the result is strictly undefined but ends up calling the wrong function.

How do I then create a variable amount of these objects? Am I stuck with creating them and deleting them explicitly?
"Since your object is not correctly constructed, the result is strictly undefined but ends up calling the wrong function." How would I go about correctly creating the object?
You can create new ones on the heap with new object(). Usually, polymorphism works best when you're allocating objects on the heap anyway.
I see. Then I shall make a class to create instances on the heap. I would like to keep the end programming to a minimum.

Collectives™ on Stack Overflow

Inheritance Confusion

1 Answer 1

4 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

4 Comments

Related