stack object

#include <iostream>
#include <stack>
using namespace std;

class Animal {};
class Dog : public Animal {};

int main ( )
{
    stack<Animal> mystack;

    Animal *x = new Dog( );
    mystack.push(*x);

    Animal y = mystack.top( );
    Dog z = dynamic_cast<Dog> y ; // this line doesnt work, how could I fix it?

    return 0;
}

 

Containers in C++ have value semantics, i.e., the line above only copies the
Animal part of the Dog object. What the stack contains is an honest to God
Animal and no Dog.

>
Animal y = mystack.top( );

That way, you retrieve the Animal you stored.

Dog z = ( Dog ) y ; // this line doesnt work, how could I fix it?

You should get rid of the C-style cast. But anyway, the line above should
not succeed. The Dog part of the object has been lost when you stored it in
the stack.

return 0;
}

If you need a polymorphic stack, you might try

stack< Animal * >


Technically, if D is derived from T, there are two natural maps:

a) a projection from values of type D to values of type T. This map is
called "slicing".

b) an injection from values of type D* to values of type T*. This map is
what people usually call the is-a-relation. It is important to see that it
holds on the level of pointers (or references, but that does not matter in
the context of containers).