Weird pointer behavior C++ / inheritance

Question

I'm currently working with pointers and I'm wondering if I'm doing something that simply does not work.

For some background, I have created a base class and a derived class. This derived class inherits some member variables and some get/set functions for these variables. This derived class also implements two pure virtual functions that it inherits from the base class.

Now in the main file that contains the code that interacts with these classes, I have three functions, call them f1, main, and f2.

F1 creates an instance of the derived class and returns a base class pointer pointing to this derived class. Within this class F1, I checked to see the int member variable has been set to the correct number, and I also check to see if the virtual functions that the derived class inherits was correctly implemented. Both the variable and the function are set/working properly in the F1 Scope.

Main recieves this base class pointer pointing to this derived class. Within this main function, I again check to see the int member variable has been set to the correct number, and I also check to see if the virtual functions that the derived class inherits was correctly implemented. Both the variable and the function are set/working properly in the Main Scope.

However, when I pass the pointer as an base class pointer argument to function F2. The int member variable gets set to 0, and when I access the virtual function, I recieve a segmentation fault/core dump error.

In a effort to further narrow down the causes, I accessed the derived class implementation files, and I created an instance of the object within the implementation files, and saw that everything was working as expected.

To sum up, I have a base class pointer pointing to a derived class object. Function calls work perfectly on this pointer in the function that it is made and in the function that it is returned to. It is only when the pointer is passed on as an argument of the base class pointer that I begin to see member variables getting set to 0 and the function calls leading to a segmentation fault/coredump.

Is what I'm trying to do something not allowed in C++? Thanks for any help anyone can give me.

edited: I've attached code below. Creature is the base case; Goblin is the derived Case; function F1:

Creature* characterSelect()
{
    Creature* creature;
    Goblin gb1 = Goblin();
    creature = &gb1;
    return creature;
}

This would be a lot easier if you could post some small example code instead of trying to explain in words — Cory Kramer, May 07 '15 at 02:21
Code, instead of English, would make it easier to see what's going on. — Michael Price, May 07 '15 at 02:22
please post your source code as that would be easier to understand. — Christian Abella, May 07 '15 at 02:22
My guess is that something is getting destructed earlier than you think, but without seeing the code, it's just a guess. — Michael Price, May 07 '15 at 02:24
My guess is that f1 does this: `Base* f1() { Derived d; return &d; }` and the problem has nothing to do with inheritance — StenSoft, May 07 '15 at 02:32
Sorry I thought it would've been more confusing if included code haha; I'll upload code when I get back home...; However, if someone asked you to do what I described, would you consider it possible? Or am I describing something c++ doesn't do? @stensoft i do what you said above but I create a base class pointer variable to point to derived d and then return that pointer variable; michael price I don't have a deconstructor written; is that something I need to do? — wangjamesy, May 07 '15 at 02:57

score 5 · Accepted Answer · edited May 23 '17 at 11:43

Creature* creature;
Goblin gb1 = Goblin();
creature = &gb1;
return creature;

You're returning a reference to an object on the stack; trying to access it after the function has returned is undefined behavior (i.e. bad). That memory gets reclaimed, it may still be valid, until it gets overwritten; this is why you saw stuff still working in main.

You need to create your goblin with new:

Goblin *gb1 = new Goblin();
return gb1;

That way it's heap allocated, and the Goblin instance will persist when you pass it around.

See: returning local variables

"So when do I delete it?"
Read up on the concept of "ownership" -- you need to keep track of who the Goblin instance "belongs" to, and whenever there are no more relevant owners, that's when you delete it. In real code, you wouldn't want to use bare pointers anyway, instead you use "smart pointers" (i.e. std::shared_ptr or std::unique_ptr) which keep track of that for you and automatically delete when the object is no longer needed.

THANK YOU; the function is working exactly as planned now! just a quick follow up question though, if I want to delete the allocated memory after using it, do I delete at the very end of my main function and do I delete the pointer variable in the main function that the Goblin variable was returned to from F1? thanks!!!!!! — wangjamesy, May 07 '15 at 04:26
You delete the pointer wherever you want/need to delete it. It all depends on the implementation. You delete the pointer, which points to the memory allocated by `new Goblin`, however the pointer may now be called. — Blacktempel, May 07 '15 at 04:52

Weird pointer behavior C++ / inheritance

1 Answers1